import { AllowedComponentProps } from 'vue';
import { BboxHandler } from 'facilmap-leaflet';
import { Component } from 'vue';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentPublicInstance } from 'vue';
import { ComputedGetter } from 'vue';
import { ComputedRef } from 'vue';
import { Control } from 'leaflet';
import { ControlOptions } from 'leaflet';
import { CRU } from 'facilmap-types';
import { DebouncedFunc } from 'lodash';
import { DeepReadonly } from 'vue';
import { default as default_2 } from 'facilmap-client';
import { default as default_3 } from 'bootstrap/js/dist/tooltip';
import { default as default_4 } from 'bootstrap/js/dist/modal';
import { DefineComponent } from 'vue';
import { Directive } from 'vue';
import { Emitter } from 'mitt';
import { Evented } from 'leaflet';
import { ExportFormat } from 'facilmap-types';
import { ExtractPropTypes } from 'vue';
import { ExtraInfo } from 'facilmap-types';
import { Field } from 'facilmap-types';
import { FilterFunc } from 'facilmap-utils';
import { FindOnMapLine } from 'facilmap-types';
import { FindOnMapMarker } from 'facilmap-types';
import { FindOnMapResult } from 'facilmap-types';
import { GeoJsonExport } from 'facilmap-types';
import { Geometry } from 'geojson';
import { Handler } from 'leaflet';
import { HashHandler } from 'facilmap-leaflet';
import { HashQuery } from 'facilmap-leaflet';
import { HistoryEntry } from 'facilmap-types';
import { i18n } from 'i18next';
import { ID } from 'facilmap-types';
import { LatLng } from 'leaflet';
import { LatLngBounds } from 'leaflet';
import { LeafletEvent } from 'leaflet';
import { Line } from 'facilmap-types';
import { LineFeature } from 'facilmap-types';
import { LinesLayer } from 'facilmap-leaflet';
import { LineWithTrackPoints } from 'facilmap-client';
import { Map as Map_2 } from 'leaflet';
import { Marker } from 'facilmap-types';
import { MarkerFeature } from 'facilmap-types';
import { MarkersLayer } from 'facilmap-leaflet';
import { Modifier } from '@popperjs/core';
import { ObjectDiffItem } from 'facilmap-utils';
import { OverpassElement } from 'facilmap-leaflet';
import { OverpassLayer } from 'facilmap-leaflet';
import { OverpassPreset } from 'facilmap-leaflet';
import { PadId } from 'facilmap-types';
import { Point } from 'facilmap-types';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RendererElement } from 'vue';
import { RendererNode } from 'vue';
import { RouteMode as RouteMode_2 } from 'facilmap-types';
import { RouteWithTrackPoints } from 'facilmap-client';
import { SearchResult } from 'facilmap-types';
import { SearchResultsLayer } from 'facilmap-leaflet';
import { ShallowUnwrapRef } from 'vue';
import { Shape } from 'facilmap-types';
import { Slot } from 'vue';
import { Stroke } from 'facilmap-types';
import { StyleValue } from 'vue';
import { Symbol as Symbol_2 } from 'facilmap-types';
import { TrackPoints } from 'facilmap-client';
import { Type } from 'facilmap-types';
import { VisibleLayers } from 'facilmap-leaflet';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import type * as z from 'zod';

declare type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_10<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_11<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_12<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_13<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_14<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_15<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_16<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_17<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_18<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_19<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_2<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_20<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_21<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_22<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_23<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_24<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_25<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_26<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_27<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_28<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_29<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_3<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_30<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_31<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_32<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_33<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_34<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_35<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_36<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_37<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_38<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_39<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_4<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_40<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_41<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_42<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_43<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_44<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_45<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_46<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_47<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_5<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_6<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_7<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_8<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_9<T> = T extends undefined ? never : T;

declare type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_10<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_11<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_12<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_13<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_14<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_15<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_16<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_17<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_18<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_19<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_2<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_20<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_21<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_3<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_4<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_5<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_6<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_7<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_8<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_Prettify_9<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_TypePropsToRuntimeProps<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_10<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_10<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_11<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_11<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_12<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_12<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_13<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_13<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_14<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_14<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_15<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_15<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_16<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_16<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_17<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_17<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_18<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_18<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_19<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_19<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_2<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_2<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_20<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_20<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_21<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_21<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_22<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_22<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_23<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_23<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_24<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_24<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_25<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_25<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_26<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_26<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_27<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_27<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_28<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_28<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_29<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_29<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_3<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_3<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_30<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_30<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_31<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_31<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_32<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_32<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_33<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_33<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_34<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_34<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_35<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_35<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_36<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_36<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_37<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_37<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_38<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_38<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_39<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_39<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_4<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_4<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_40<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_40<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_41<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_41<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_42<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_42<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_43<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_43<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_44<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_44<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_45<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_45<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_46<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_46<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_47<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_47<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_5<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_5<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_6<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_6<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_7<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_7<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_8<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_8<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_TypePropsToRuntimeProps_9<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: PropType<__VLS_NonUndefinedable_9<T[K]>>;
    } : {
        type: PropType<T[K]>;
        required: true;
    };
};

declare type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_10<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_10<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_11<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_11<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_12<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_12<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_13<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_13<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_14<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_14<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_15<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_15<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_16<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_16<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_17<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_17<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_18<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_18<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_19<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_19<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_2<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_2<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_20<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_20<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_21<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_21<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_3<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_3<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_4<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_4<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_5<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_5<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_6<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_6<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_7<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_7<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_8<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_8<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithDefaults_9<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify_9<P[K] & {
        default: D[K];
    }> : P[K];
};

declare type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_10<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_11<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_12<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_13<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_14<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_15<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_2<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_3<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_4<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_5<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_6<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_7<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_8<T, S> = T & {
    new (): {
        $slots: S;
    };
};

declare type __VLS_WithTemplateSlots_9<T, S> = T & {
    new (): {
        $slots: S;
    };
};

export declare const AboutDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare function addLineToMap(client: Ref<ClientContext_2>, line: LineWithTags, type: Type): Promise<SelectedItem>;

export declare function addMarkerToMap(client: Ref<ClientContext_2>, marker: MarkerWithTags, type: Type): Promise<SelectedItem>;

export declare function addToMap(context: FacilMapContext, objects: Array<({
    marker: MarkerWithTags;
} | {
    line: LineWithTags;
}) & {
    type: Type;
}>): Promise<SelectedItem[]>;

export declare const AddToMapDropdown: __VLS_WithTemplateSlots_6<DefineComponent<__VLS_TypePropsToRuntimeProps_17<{
markers?: MarkerWithTags[] | undefined;
lines?: LineWithTags[] | undefined;
label?: string | undefined;
size?: ButtonSize | undefined;
/** If true, the markers/lines entries are assumed to refer to a single object, omitting the prefix "Marker/line/polgon items as" */
isSingle?: boolean | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:isAdding": (isAdding: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_17<{
markers?: MarkerWithTags[] | undefined;
lines?: LineWithTags[] | undefined;
label?: string | undefined;
size?: ButtonSize | undefined;
/** If true, the markers/lines entries are assumed to refer to a single object, omitting the prefix "Marker/line/polgon items as" */
isSingle?: boolean | undefined;
}>>> & {
"onUpdate:isAdding"?: ((isAdding: boolean) => any) | undefined;
}, {}, {}>, {
    after?(_: {}): any;
}>;

declare function addVia(data: Parameters<typeof makeDestination>[0]): void;

export declare const Alert: __VLS_WithTemplateSlots_7<DefineComponent<__VLS_WithDefaults_9<__VLS_TypePropsToRuntimeProps_18<AlertProps>, {
type: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hide: (result: AlertResult) => void;
shown: () => void;
hidden: (result: AlertResult) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_9<__VLS_TypePropsToRuntimeProps_18<AlertProps>, {
type: string;
}>>> & {
onHide?: ((result: AlertResult) => any) | undefined;
onHidden?: ((result: AlertResult) => any) | undefined;
onShown?: (() => any) | undefined;
}, {
type: "alert" | "confirm";
}, {}>, {
    default?(_: {}): any;
}>;

export declare type AlertProps = {
    title: string;
    message: string;
    type?: "alert" | "confirm";
    variant?: ThemeColour;
    okLabel?: string;
};

export declare interface AlertResult {
    ok: boolean;
}

export declare type AnyRef<T> = T | Ref<T> | (() => T);

export declare function arrowNavigation<V>(values: V[], value: V | undefined, grid: Element, event: KeyboardEvent): V | undefined;

declare type AsyncValidationResult = Promise<SyncValidationResult>;

/**
 * Renders an element that preserves attributes manually added through the DOM.
 *
 * Usually Vue removes any attributes that are not part of the template when the component is rerendered.
 * This makes it hard to work with third-party libraries that modify the DOM directly. This component
 * creates a copy of any attributes in the DOM before each component update and renders these attributes
 * again during the update. Any DOM attributes that are (or have ever been) part of the component props
 * are ignored and rendered according to the prop value.
 *
 * Class names are handled separately in the same way: The component keeps track of class names manually
 * added through DOM operations and adds them again during render. Class names that are (or have ever been)
 * part of the "class" prop are ignored.
 */
export declare const AttributePreservingElement: __VLS_WithTemplateSlots_8<DefineComponent<__VLS_TypePropsToRuntimeProps_19<{
tag: string;
class?: string | Record<string, boolean> | (string | Record<string, boolean>)[] | undefined;
}>, {
elementRef: Ref<HTMLElement | undefined>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_19<{
tag: string;
class?: string | Record<string, boolean> | (string | Record<string, boolean>)[] | undefined;
}>>>, {}, {}>, {
    default?(_: {}): any;
}>;

declare class AttributionControl extends Control {
    options: AttributionControlOptions;
    protected _map?: Map_2;
    constructor(options?: AttributionControlOptions);
    onAdd(map: Map_2): HTMLElement;
    onRemove(map: Map_2): void;
    update(): void;
}

declare interface AttributionControlOptions extends ControlOptions {
    prefix?: string;
}

export declare interface Bookmark {
    /** ID used to open the map */
    id: PadId;
    /** Read-only ID of the map */
    padId: PadId;
    /** Last known name of the map */
    name: string;
    /** If this is defined, it is shown instead of the map name. */
    customName?: string;
}

export declare class BoxSelection extends Map_2.BoxZoom {
    _ctrlKey: boolean;
    constructor(map: Map_2);
    _onMouseDown(e: MouseEvent): void;
    _onMouseMove(e: MouseEvent): void;
    fireSelect: DebouncedFunc<(bounds: LatLngBounds) => void>;
}

export declare interface BoxSelection extends Evented {
}

export declare type Breakpoint = keyof typeof breakpointMinWidth;

declare const breakpointMinWidth: {
    xs: number;
    sm: number;
    md: number;
    lg: number;
    xl: number;
    xxl: number;
};

export declare const breakpoints: ("xs" | "sm" | "md" | "lg" | "xl" | "xxl")[];

export declare type ButtonSize = "lg" | "sm";

export declare type ButtonVariant = ThemeColour | "link" | "outline-primary" | "outline-secondary" | "outline-success" | "outline-danger" | "outline-warning" | "outline-info" | "outline-light" | "outline-dark";

export declare interface CarouselContext {
    tab: number;
    setTab(tab: number): void;
}

export declare const ClickMarkerTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type ClickMarkerTabContext = Readonly<WritableClickMarkerTabContext>;

export declare const ClientContext: DefineComponent<__VLS_TypePropsToRuntimeProps_42<{
padId: string | undefined;
serverUrl: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:padId": (padId: string | undefined) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_42<{
padId: string | undefined;
serverUrl: string;
}>>> & {
"onUpdate:padId"?: ((padId: string | undefined) => any) | undefined;
}, {}, {}>;

declare type ClientContext_2 = default_2 & {
    /** If this is a true, it means that the current pad ID was not found and a create dialog is shown for it. */
    get isCreatePad(): boolean;
    openPad(padId: string | undefined): void;
};

export declare const ColourPicker: DefineComponent<__VLS_TypePropsToRuntimeProps_20<{
modelValue: string;
validators?: Validator<string>[] | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (colour: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_20<{
modelValue: string;
validators?: Validator<string>[] | undefined;
}>>> & {
"onUpdate:modelValue"?: ((colour: string) => any) | undefined;
}, {}, {}>;

export declare function combineZoomDestinations(destinations: Array<ZoomDestination | undefined>): ZoomDestination | undefined;

export declare type ComponentProps<C extends Component> = C extends new (...args: any) => any ? Omit<InstanceType<C>['$props'], keyof VNodeProps | keyof AllowedComponentProps> : never;

export declare function computedAsync<T>(getter: ComputedGetter<Promise<T>>, onError?: (err: any) => void): Ref<T | undefined>;

/**
 * Returns a computed property that is recomputed every time the window is resized.
 */
export declare function computedOnResize<T>(getValue: () => T): Readonly<Ref<T>>;

export declare const Coordinates: DefineComponent<__VLS_TypePropsToRuntimeProps_21<{
point: Point;
ele?: number | null | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_21<{
point: Point;
ele?: number | null | undefined;
}>>>, {}, {}>;

export declare function createElevationStats(extraInfo: ExtraInfo | undefined, trackPoints: TrackPoints): Record<number, number> | null;

export declare function createLinePlaceholderHtml(colour: string, width: number, length: number, stroke: Stroke): string;

export declare const CustomImportDialog: DefineComponent<__VLS_WithDefaults_6<__VLS_TypePropsToRuntimeProps_11<{
customTypes?: Record<number, Omit<{
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}, "id" | "padId">> | undefined;
results: FileResult[];
}>, {
customTypes: () => {};
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_6<__VLS_TypePropsToRuntimeProps_11<{
customTypes?: Record<number, Omit<{
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}, "id" | "padId">> | undefined;
results: FileResult[];
}>, {
customTypes: () => {};
}>>> & {
onHidden?: (() => any) | undefined;
}, {
customTypes: FileResultObject["types"];
}, {}>;

export declare interface CustomSubmitEvent extends ExtendableEventMixin {
    preventDefault(): void;
}

declare const _default: DefineComponent<__VLS_TypePropsToRuntimeProps_8<{
proposedAdminId?: string | undefined;
noCancel?: boolean | undefined;
isCreate?: boolean | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hide: () => void;
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_8<{
proposedAdminId?: string | undefined;
noCancel?: boolean | undefined;
isCreate?: boolean | undefined;
}>>> & {
onHide?: (() => any) | undefined;
onHidden?: (() => any) | undefined;
}, {}, {}>;
export { _default as PadIdEdit }
export { _default as PadSettingsDialog }

declare interface Destination extends RouteDestination {
    query: string;
    loadingQuery?: string;
    loadingPromise?: Promise<void>;
    loadedQuery?: string;
    searchSuggestions?: SearchSuggestion[];
    mapSuggestions?: MapSuggestion[];
    selectedSuggestion?: Suggestion;
}

export declare type DistributedKeyOf<T> = T extends any ? keyof T : never;

export declare function drawLine(type: Type, context: FacilMapContext, toasts: ToastContext): Promise<void>;

export declare function drawMarker(type: Type, context: FacilMapContext, toasts: ToastContext): void;

export declare const DropdownMenu: __VLS_WithTemplateSlots_9<DefineComponent<__VLS_WithDefaults_10<__VLS_TypePropsToRuntimeProps_22<{
isOpen?: boolean | undefined;
noWrapper?: boolean | undefined;
class?: string | undefined;
buttonClass?: string | undefined;
menuClass?: string | undefined;
variant?: ButtonVariant | undefined;
noCaret?: boolean | undefined;
label?: string | undefined;
size?: ButtonSize | undefined;
isDisabled?: boolean | undefined;
/** Disables the dropdown and shows a spinner on the button. */
isBusy?: boolean | undefined;
/** Shows a spinner instead of the dropdown items. */
isLoading?: boolean | undefined;
tag?: string | undefined;
isLink?: boolean | undefined;
tabindex?: number | undefined;
tooltip?: string | undefined;
tooltipPlacement?: TooltipPlacement | undefined;
maxWidth?: string | undefined;
}>, {
isOpen: undefined;
noWrapper: boolean;
variant: string;
noCaret: boolean;
tag: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:isOpen": (args_0: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_10<__VLS_TypePropsToRuntimeProps_22<{
isOpen?: boolean | undefined;
noWrapper?: boolean | undefined;
class?: string | undefined;
buttonClass?: string | undefined;
menuClass?: string | undefined;
variant?: ButtonVariant | undefined;
noCaret?: boolean | undefined;
label?: string | undefined;
size?: ButtonSize | undefined;
isDisabled?: boolean | undefined;
/** Disables the dropdown and shows a spinner on the button. */
isBusy?: boolean | undefined;
/** Shows a spinner instead of the dropdown items. */
isLoading?: boolean | undefined;
tag?: string | undefined;
isLink?: boolean | undefined;
tabindex?: number | undefined;
tooltip?: string | undefined;
tooltipPlacement?: TooltipPlacement | undefined;
maxWidth?: string | undefined;
}>, {
isOpen: undefined;
noWrapper: boolean;
variant: string;
noCaret: boolean;
tag: string;
}>>> & {
"onUpdate:isOpen"?: ((args_0: boolean) => any) | undefined;
}, {
variant: ButtonVariant;
tag: string;
isOpen: boolean;
noWrapper: boolean;
noCaret: boolean;
}, {}>, {
    label?(_: {}): any;
    default?(_: {}): any;
}>;

export declare const EditFilterDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare const EditLineDialog: DefineComponent<__VLS_TypePropsToRuntimeProps_43<{
lineId: ID;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_43<{
lineId: ID;
}>>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare const EditMarkerDialog: DefineComponent<__VLS_TypePropsToRuntimeProps_44<{
markerId: ID;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_44<{
markerId: ID;
}>>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare const EditTypeDialog: DefineComponent<__VLS_TypePropsToRuntimeProps<{
typeId: ID | "createMarkerType" | "createLineType";
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
typeId: ID | "createMarkerType" | "createLineType";
}>>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare const EditTypeDropdownDialog: DefineComponent<__VLS_TypePropsToRuntimeProps_2<{
type: Type<CRU.READ | CRU.CREATE_VALIDATED>;
field: Field;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
"update:field": (field: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_2<{
type: Type<CRU.READ | CRU.CREATE_VALIDATED>;
field: Field;
}>>> & {
onHidden?: (() => any) | undefined;
"onUpdate:field"?: ((field: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}) => any) | undefined;
}, {}, {}>;

export declare const ElevationPlot: DefineComponent<__VLS_TypePropsToRuntimeProps_23<{
route: RouteWithTrackPoints | LineWithTrackPoints;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_23<{
route: RouteWithTrackPoints | LineWithTrackPoints;
}>>>, {}, {}>;

export declare const ElevationStats: DefineComponent<__VLS_TypePropsToRuntimeProps_24<{
route: LineWithTrackPoints | RouteWithTrackPoints;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_24<{
route: LineWithTrackPoints | RouteWithTrackPoints;
}>>>, {}, {}>;

export declare const ExportDropdown: DefineComponent<__VLS_TypePropsToRuntimeProps_25<{
filename: string;
getExport: (format: ExportFormat) => Promise<string>;
isDisabled?: boolean | undefined;
size?: ButtonSize | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_25<{
filename: string;
getExport: (format: ExportFormat) => Promise<string>;
isDisabled?: boolean | undefined;
size?: ButtonSize | undefined;
}>>>, {}, {}>;

/**
 * An event whose handler can be delayed in a similar fashion to the native ExtendableEvent
 * (https://developer.mozilla.org/en-US/docs/Web/API/ExtendableEvent/ExtendableEvent).
 * This enables a pattern described here: https://github.com/vuejs/vue/issues/5443#issuecomment-379284227
 * as a workaround for the fact that Vue event handlers cannot be async.
 */
export declare interface ExtendableEventMixin {
    waitUntil(promise: Promise<void>): void;
    _hasAwaited?: boolean;
    _promises?: Array<Promise<void>>;
    _awaitPromises(): Promise<void>;
}

export declare const extendableEventMixin: ExtendableEventMixin;

export declare const FacilMap: __VLS_WithTemplateSlots_15<DefineComponent<__VLS_TypePropsToRuntimeProps_45<{
baseUrl: string;
serverUrl: string;
padId: string | undefined;
appName?: string | undefined;
hideCommercialMapLinks?: boolean | undefined;
settings?: Partial<FacilMapSettings> | undefined;
}>, {
context: Readonly<Ref<FacilMapContext | undefined>>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:padId": (padId: string | undefined) => void;
"update:padName": (padName: string | undefined) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_45<{
baseUrl: string;
serverUrl: string;
padId: string | undefined;
appName?: string | undefined;
hideCommercialMapLinks?: boolean | undefined;
settings?: Partial<FacilMapSettings> | undefined;
}>>> & {
"onUpdate:padId"?: ((padId: string | undefined) => any) | undefined;
"onUpdate:padName"?: ((padName: string | undefined) => any) | undefined;
}, {}, {}>, {
    before?(_: {}): any;
    after?(_: {}): any;
    default?(_: {}): any;
}>;

export declare interface FacilMapComponents {
    searchBox?: SearchBoxContext;
    client?: ClientContext_2;
    map?: MapContext;
    searchFormTab?: SearchFormTabContext;
    routeFormTab?: RouteFormTabContext;
    clickMarkerTab?: ClickMarkerTabContext;
    importTab?: ImportTabContext;
}

export declare type FacilMapContext = Readonly<Omit<WritableFacilMapContext, "settings" | "components">> & {
    settings: Readonly<WritableFacilMapContext["settings"]>;
    components: Readonly<WritableFacilMapContext["components"]>;
};

export declare const FacilMapContextProvider: __VLS_WithTemplateSlots<DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps_3<{
baseUrl: string;
appName?: string | undefined;
hideCommercialMapLinks?: boolean | undefined;
settings?: Partial<FacilMapSettings> | undefined;
}>, {
appName: string;
}>, {
context: FacilMapContext;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps_3<{
baseUrl: string;
appName?: string | undefined;
hideCommercialMapLinks?: boolean | undefined;
settings?: Partial<FacilMapSettings> | undefined;
}>, {
appName: string;
}>>>, {
appName: string;
}, {}>, {
    default?(_: {}): any;
}>;

export declare interface FacilMapSettings {
    toolbox: boolean;
    search: boolean;
    route: boolean;
    pois: boolean;
    locate: boolean;
    autofocus: boolean;
    legend: boolean;
    interactive: boolean;
    linkLogo: boolean;
    updateHash: boolean;
    routing: boolean;
    advancedRouting: boolean;
}

export declare const FieldInput: DefineComponent<__VLS_WithDefaults_11<__VLS_TypePropsToRuntimeProps_26<{
field: Field;
ignoreDefault?: boolean | undefined;
modelValue?: string | undefined;
id?: string | undefined;
showCheckboxLabel?: boolean | undefined;
}>, {
ignoreDefault: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string | undefined) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_11<__VLS_TypePropsToRuntimeProps_26<{
field: Field;
ignoreDefault?: boolean | undefined;
modelValue?: string | undefined;
id?: string | undefined;
showCheckboxLabel?: boolean | undefined;
}>, {
ignoreDefault: boolean;
}>>> & {
"onUpdate:modelValue"?: ((value: string | undefined) => any) | undefined;
}, {
ignoreDefault: boolean;
}, {}>;

export declare type FileResult = SearchResult & {
    isFileResult: true;
    fmTypeId?: number;
    fmProperties?: FmFeatureProperties;
};

export declare interface FileResultObject {
    features: FileResult[];
    views: GeoJsonExport["facilmap"]["views"];
    types: GeoJsonExport["facilmap"]["types"];
    errors: boolean;
}

export declare const FileResults: DefineComponent<__VLS_WithDefaults_20<__VLS_TypePropsToRuntimeProps_46<{
layerId: number;
file: FileResultObject;
/** When clicking a search result, union zoom to it. Normal zoom is done when clicking the zoom button. */
unionZoom?: boolean | undefined;
/** When clicking or selecting a search result, zoom to it. */
autoZoom?: boolean | undefined;
}>, {
unionZoom: boolean;
autoZoom: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_20<__VLS_TypePropsToRuntimeProps_46<{
layerId: number;
file: FileResultObject;
/** When clicking a search result, union zoom to it. Normal zoom is done when clicking the zoom button. */
unionZoom?: boolean | undefined;
/** When clicking or selecting a search result, zoom to it. */
autoZoom?: boolean | undefined;
}>, {
unionZoom: boolean;
autoZoom: boolean;
}>>>, {
autoZoom: boolean;
unionZoom: boolean;
}, {}>;

/**
 * Allows to run multiple cleanup functions in watchers. Due to https://github.com/vuejs/core/issues/3341, only the last
 * onCleanup function specified is called. Call this with the onCleanup function given by the watcher and register
 * multiple cleanup callbacks by calling the onCleanup method returned by this function.
 */
export declare function fixOnCleanup(onCleanup: (cleanupFn: () => void) => void): (cleanupFn: () => void) => void;

export declare function flyTo(map: Map_2, destination: ZoomDestination, smooth?: boolean): void;

declare type FmFeatureProperties = Partial<MarkerFeature["properties"]> | Partial<LineFeature["properties"]>;

export declare class FmHeightgraph extends Control.Heightgraph {
    private translatedMapping;
    constructor(options?: any);
    addData(extraInfo: ExtraInfo | undefined, trackPoints: TrackPoints): void;
    _internalMousemoveHandler(...args: any[]): void;
    _appendScales(): void;
    _prepareData(): void;
    _showMapMarker(...args: any[]): void;
}

export declare function getGridColumnsCount(grid: Element): number;

export declare function getHashQuery(map: Map_2, client: ClientContext_2, items: DeepReadonly<SelectedItem>[]): HashQuery | undefined;

export declare function getI18n(): {
    t: i18n["t"];
    changeLanguage: (lang: string) => Promise<void>;
};

export declare function getLabelsForHistoryEntry(client: ClientContext_2, entry: HistoryEntry): HistoryEntryLabels;

export declare function getLegendItems(context: FacilMapContext): LegendType[];

/**
 * An array of popper modifiers that uses popper-max-size-modifier to shrink the popover to prevent overflow
 * rather than move it, as is the default in Bootstrap.
 */
export declare const getMaxSizeModifiers: ({ maxWidth }?: {
    maxWidth?: string;
}) => Array<Partial<Modifier<any, any>>>;

export declare function getUniqueId(scope?: string): string;

export declare function getValidatedForm(form: HTMLFormElement): Readonly<ValidatedFormData> | undefined;

export declare function getZodValidator(validator: z.ZodType): (val: any) => string | undefined;

export declare function getZoomDestinationForGeoJSON(geojson: DeepReadonly<Geometry>): ZoomDestination | undefined;

export declare function getZoomDestinationForLine(line: Line | FindOnMapLine): ZoomDestination;

export declare function getZoomDestinationForMapResult(result: FindOnMapResult): ZoomDestination;

export declare function getZoomDestinationForMarker(marker: Marker | FindOnMapMarker | OverpassElement): ZoomDestination;

export declare function getZoomDestinationForResults(results: Array<SearchResult | FindOnMapResult>): ZoomDestination | undefined;

export declare function getZoomDestinationForRoute(route: RouteWithTrackPoints): ZoomDestination;

export declare function getZoomDestinationForSearchResult(result: DeepReadonly<SearchResult>): ZoomDestination | undefined;

export declare function hideAllModals(): void;

export declare function hideAllTooltips(): void;

export declare const HistoryDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare interface HistoryEntryLabels {
    description: string;
    revert?: {
        title: string;
        message: string;
        button: string;
        okLabel: string;
    };
    diff?: Array<ObjectDiffItem>;
}

/**
 * Renders an element that opens a popover on large screens and a modal on small screens.
 */
export declare const HybridPopover: __VLS_WithTemplateSlots_10<DefineComponent<__VLS_WithDefaults_12<__VLS_TypePropsToRuntimeProps_27<{
show?: boolean | undefined;
title?: string | undefined;
customClass?: string | undefined;
/** If true, the width of the popover will be fixed to the width of the element. */
enforceElementWidth?: boolean | undefined;
/** If true, a click of the reference element will not toggle the popover. */
ignoreClick?: boolean | undefined;
}>, {
show: undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hide: () => void;
"update:show": (show: boolean) => void;
shown: () => void;
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_12<__VLS_TypePropsToRuntimeProps_27<{
show?: boolean | undefined;
title?: string | undefined;
customClass?: string | undefined;
/** If true, the width of the popover will be fixed to the width of the element. */
enforceElementWidth?: boolean | undefined;
/** If true, a click of the reference element will not toggle the popover. */
ignoreClick?: boolean | undefined;
}>, {
show: undefined;
}>>> & {
onHide?: (() => any) | undefined;
onHidden?: (() => any) | undefined;
onShown?: (() => any) | undefined;
"onUpdate:show"?: ((show: boolean) => any) | undefined;
}, {
show: boolean;
}, {}>, {
    trigger?(_: {}): any;
    default?(_: {
        isModal: boolean;
        close: () => void;
    }): any;
}>;

export declare const i18nResourceChangeCounter: Ref<number>;

export declare const Icon: DefineComponent<__VLS_WithDefaults_13<__VLS_TypePropsToRuntimeProps_28<{
icon: string | undefined;
alt?: string | undefined;
size?: string | undefined;
async?: boolean | undefined;
}>, {
size: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_13<__VLS_TypePropsToRuntimeProps_28<{
icon: string | undefined;
alt?: string | undefined;
size?: string | undefined;
async?: boolean | undefined;
}>, {
size: string;
}>>>, {
size: string;
}, {}>;

export declare const ImportTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type ImportTabContext = Readonly<WritableImportTabContext>;

export declare function isFileResult(result: SearchResult | FindOnMapResult | FileResult): result is FileResult;

export declare function isLanguageExplicit(): boolean;

export declare function isLineResult(result: SearchResult | FindOnMapResult | FileResult): boolean;

export declare function isMapResult(result: SearchResult | FindOnMapResult | FileResult): result is FindOnMapResult;

export declare function isMarkerResult(result: SearchResult | FindOnMapResult | FileResult): boolean;

export declare function isMaxBreakpoint(breakpoint: Breakpoint): boolean;

export declare function isSearchResult(result: SearchResult | FindOnMapResult | FileResult): result is SearchResult;

export declare function isUnitsExplicit(): boolean;

export declare const LeafletMap: __VLS_WithTemplateSlots_2<DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>, {
    before?(_: {}): any;
    default?(_: {}): any;
    after?(_: {}): any;
}>;

export declare const Legend: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare const LegendContent: DefineComponent<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_4<{
legend1?: string | undefined;
legend2?: string | undefined;
items: LegendType[];
noPopover?: boolean | undefined;
}>, {
noPopover: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_4<{
legend1?: string | undefined;
legend2?: string | undefined;
items: LegendType[];
noPopover?: boolean | undefined;
}>, {
noPopover: boolean;
}>>>, {
noPopover: boolean;
}, {}>;

export declare interface LegendItem {
    key: string;
    value: string;
    label?: string;
    field?: string;
    filtered?: boolean;
    first?: boolean;
    strikethrough?: boolean;
    colour?: string;
    symbol?: Symbol_2;
    shape?: Shape;
    width?: number;
    stroke?: Stroke;
    bright?: boolean;
}

export declare interface LegendType {
    key: string;
    type: Type['type'];
    typeId: ID;
    name: string;
    items: LegendItem[];
    filtered: boolean;
}

export declare const LineInfo: DefineComponent<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_5<{
lineId: ID;
showBackButton?: boolean | undefined;
}>, {
showBackButton: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
back: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_5<{
lineId: ID;
showBackButton?: boolean | undefined;
}>, {
showBackButton: boolean;
}>>> & {
onBack?: (() => any) | undefined;
}, {
showBackButton: boolean;
}, {}>;

export declare const LineInfoTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type LineWithTags = Omit<Line<CRU.CREATE>, "typeId"> & {
    tags?: Record<string, string>;
};

declare function makeDestination({ query, searchSuggestions, mapSuggestions, selectedSuggestion }: {
    query: string;
    searchSuggestions?: SearchResult[];
    mapSuggestions?: FindOnMapResult[];
    selectedSuggestion?: SearchResult | FindOnMapResult;
}): Destination;

export declare const ManageBookmarksDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare const ManageTypesDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare const ManageViewsDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare interface MapComponents {
    attribution: AttributionControl;
    bboxHandler: BboxHandler;
    container: HTMLElement;
    graphicScale: any;
    hashHandler: HashHandler & {
        _fmActivate: () => Promise<void>;
    };
    linesLayer: LinesLayer;
    locateControl?: L.Control.Locate;
    map: Map_2;
    markersLayer: MarkersLayer;
    mousePosition: L.Control.MousePosition;
    overpassLayer: OverpassLayer;
    searchResultsLayer: SearchResultsLayer;
    selectionHandler: SelectionHandler;
}

export declare type MapContext = DeepReadonly<Omit<WritableMapContext, "components">> & {
    readonly components: Readonly<WritableMapContext["components"]>;
};

export declare type MapContextData = {
    center: LatLng;
    zoom: number;
    bounds: LatLngBounds;
    layers: VisibleLayers;
    filter: string | undefined;
    filterFunc: FilterFunc;
    hash: string;
    showToolbox: boolean;
    selection: DeepReadonly<SelectedItem>[];
    activeQuery: HashQuery | undefined;
    fallbackQuery: HashQuery | undefined;
    setFallbackQuery: (query: HashQuery | undefined) => void;
    interaction: boolean;
    loading: number;
    overpassIsCustom: boolean;
    overpassPresets: OverpassPreset[];
    overpassCustom: string;
    overpassMessage: string | undefined;
    location: Point | undefined;
    components: MapComponents;
    loaded: boolean;
    fatalError: string | undefined;
    /** Increase mapContext.loading while the given async function is running. */
    runOperation: <R>(operation: () => Promise<R>) => Promise<R>;
};

export declare type MapContextEvents = {
    "open-selection": {
        selection: DeepReadonly<SelectedItem[]>;
    };
};

export declare function mapRef<K>(map: Map<K, Element | ComponentPublicInstance>, key: K): (ref: Element | ComponentPublicInstance | null) => void;

declare type MapSuggestion = FindOnMapResult & {
    kind: "marker";
};

/**
 * Maps the tags from a search result to fields whose name is similar to the tag key (ignoring case and
 * non-letters). The resulting object can be used as "data" for a marker and line.
 */
export declare function mapTagsToType(tags: Record<string, string>, type: Type): Record<string, string>;

export declare const MarkerInfo: DefineComponent<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_6<{
markerId: ID;
showBackButton?: boolean | undefined;
}>, {
showBackButton: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
back: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_6<{
markerId: ID;
showBackButton?: boolean | undefined;
}>, {
showBackButton: boolean;
}>>> & {
onBack?: (() => any) | undefined;
}, {
showBackButton: boolean;
}, {}>;

export declare const MarkerInfoTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type MarkerWithTags = Omit<Marker<CRU.CREATE>, "typeId"> & {
    tags?: Record<string, string>;
};

export declare function mergeTypeObject(oldObject: Type, newObject: Type, targetObject: Type<CRU.CREATE_VALIDATED | CRU.READ>): void;

export declare interface ModalActions {
    hide: () => void;
}

export declare interface ModalConfig {
    /** Will be called when the fade-in animation has finished. */
    onShown?: (event: default_4.Event) => void;
    /** Will be called before the fade-out animation when the modal is closed. */
    onHide?: (event: default_4.Event) => void;
    /** Will be called after the fade-out animation when the modal is closed. */
    onHidden?: (event: default_4.Event) => void;
    /** If true, the modal can not be closed by clicking the backdrop. */
    static?: Ref<boolean>;
    /** If true, the modal can not be closed by pressing Escape. */
    noEscape?: Ref<boolean>;
}

export declare const ModalDialog: __VLS_WithTemplateSlots_11<DefineComponent<__VLS_WithDefaults_14<__VLS_TypePropsToRuntimeProps_29<{
title?: string | undefined;
class?: string | undefined;
/** If true, the user is prevented from closing the dialog. */
noCancel?: boolean | undefined;
isBusy?: boolean | undefined;
/** If true, the Save button will always be shown (also if isModified is false). */
isCreate?: boolean | undefined;
/** If false, a Close button will be shown instead of a Save button (except is isCreate is true). */
isModified?: boolean | undefined;
size?: "default" | "sm" | "lg" | "xl" | undefined;
okLabel?: string | undefined;
okVariant?: ThemeColour | undefined;
formValidationError?: string | undefined;
action?: string | undefined;
target?: string | undefined;
}>, {
isModified: boolean;
size: string;
}>, {
formData: {
readonly isTouched: boolean;
readonly isSubmitting: boolean;
readonly isValidating: boolean;
readonly formValidationError: string | undefined;
readonly submit: () => Promise<void>;
readonly setValidationPromise: (element: Element, promise: Promise<any> | undefined) => void;
} | undefined;
modal: {
readonly hide: () => void;
};
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
submit: (event: CustomSubmitEvent) => void;
hide: () => void;
shown: () => void;
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_14<__VLS_TypePropsToRuntimeProps_29<{
title?: string | undefined;
class?: string | undefined;
/** If true, the user is prevented from closing the dialog. */
noCancel?: boolean | undefined;
isBusy?: boolean | undefined;
/** If true, the Save button will always be shown (also if isModified is false). */
isCreate?: boolean | undefined;
/** If false, a Close button will be shown instead of a Save button (except is isCreate is true). */
isModified?: boolean | undefined;
size?: "default" | "sm" | "lg" | "xl" | undefined;
okLabel?: string | undefined;
okVariant?: ThemeColour | undefined;
formValidationError?: string | undefined;
action?: string | undefined;
target?: string | undefined;
}>, {
isModified: boolean;
size: string;
}>>> & {
onHide?: (() => any) | undefined;
onHidden?: (() => any) | undefined;
onSubmit?: ((event: CustomSubmitEvent) => any) | undefined;
onShown?: (() => any) | undefined;
}, {
size: "default" | "sm" | "lg" | "xl";
isModified: boolean;
}, {}>, {
    default?(_: {
        formData: {
            readonly isTouched: boolean;
            readonly isSubmitting: boolean;
            readonly isValidating: boolean;
            readonly formValidationError: string | undefined;
            readonly submit: () => Promise<void>;
            readonly setValidationPromise: (element: Element, promise: Promise<any> | undefined) => void;
        } | undefined;
        modal: {
            readonly hide: () => void;
        };
    }): any;
    "footer-left"?(_: {
        formData: {
            readonly isTouched: boolean;
            readonly isSubmitting: boolean;
            readonly isValidating: boolean;
            readonly formValidationError: string | undefined;
            readonly submit: () => Promise<void>;
            readonly setValidationPromise: (element: Element, promise: Promise<any> | undefined) => void;
        } | undefined;
        modal: {
            readonly hide: () => void;
        };
    }): any;
}>;

export declare function moveMarker(markerId: ID, context: FacilMapContext, toasts: ToastContext): void;

export declare const MultipleInfo: DefineComponent<__VLS_TypePropsToRuntimeProps_7<{
objects: Array<Marker | Line>;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"click-object": (object: {
symbol: string;
size: number;
name: string;
typeId: number;
shape: string;
colour: string;
data: Record<string, string>;
ele: number | null;
lat: number;
lon: number;
id: number;
padId: string;
} | {
name: string;
typeId: number;
colour: string;
data: Record<string, string>;
id: number;
padId: string;
distance: number;
ascent: number | null;
descent: number | null;
time: number | null;
top: number;
bottom: number;
left: number;
right: number;
routePoints: {
lat: number;
lon: number;
}[];
mode: string;
width: number;
stroke: "" | "dashed" | "dotted";
extraInfo: Record<string, [number, number, number][]> | null;
}, event: MouseEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_7<{
objects: Array<Marker | Line>;
}>>> & {
"onClick-object"?: ((object: {
symbol: string;
size: number;
name: string;
typeId: number;
shape: string;
colour: string;
data: Record<string, string>;
ele: number | null;
lat: number;
lon: number;
id: number;
padId: string;
} | {
name: string;
typeId: number;
colour: string;
data: Record<string, string>;
id: number;
padId: string;
distance: number;
ascent: number | null;
descent: number | null;
time: number | null;
top: number;
bottom: number;
left: number;
right: number;
routePoints: {
lat: number;
lon: number;
}[];
mode: string;
width: number;
stroke: "" | "dashed" | "dotted";
extraInfo: Record<string, [number, number, number][]> | null;
}, event: MouseEvent) => any) | undefined;
}, {}, {}>;

export declare const MultipleInfoTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare function normalizeZoomDestination(map: Map_2, destination: ZoomDestination): Required<ZoomDestination> & Pick<ZoomDestination, "bounds">;

export declare const OpenMapDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare function openSpecialQuery(query: string, context: FacilMapContext, zoom: boolean, smooth?: boolean): Promise<boolean>;

export declare function overpassElementsToMarkersWithTags(elements: OverpassElement[]): MarkerWithTags[];

export declare const OverpassForm: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare const OverpassFormTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare function parseFiles(files: string[]): Promise<FileResultObject>;

export declare const Picker: __VLS_WithTemplateSlots_12<DefineComponent<__VLS_WithDefaults_15<__VLS_TypePropsToRuntimeProps_30<{
id?: string | undefined;
customClass?: string | undefined;
disabled?: boolean | undefined;
validators?: Validator<string>[] | undefined;
modelValue: string;
/** If true, the width of the popover will be fixed to the width of the element. */
enforceElementWidth?: boolean | undefined;
previewStyle?: StyleValue;
}>, {
enforceElementWidth: boolean;
disabled: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
keydown: (event: KeyboardEvent) => void;
"update:modelValue": (value: string) => void;
focusPopover: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_15<__VLS_TypePropsToRuntimeProps_30<{
id?: string | undefined;
customClass?: string | undefined;
disabled?: boolean | undefined;
validators?: Validator<string>[] | undefined;
modelValue: string;
/** If true, the width of the popover will be fixed to the width of the element. */
enforceElementWidth?: boolean | undefined;
previewStyle?: StyleValue;
}>, {
enforceElementWidth: boolean;
disabled: boolean;
}>>> & {
onKeydown?: ((event: KeyboardEvent) => any) | undefined;
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
onFocusPopover?: (() => any) | undefined;
}, {
disabled: boolean;
enforceElementWidth: boolean;
}, {}>, {
    preview?(_: {}): any;
    default?(_: {
        isModal: boolean;
        close: () => void;
    }): any;
}>;

export declare const Popover: __VLS_WithTemplateSlots_13<DefineComponent<__VLS_WithDefaults_16<__VLS_TypePropsToRuntimeProps_31<{
element: HTMLElement | undefined;
show: boolean;
hideOnOutsideClick?: boolean | undefined;
/** If true, the width of the popover will be fixed to the width of the element. */
enforceElementWidth?: boolean | undefined;
placement?: default_3.PopoverPlacement | undefined;
}>, {
placement: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hide: () => void;
"update:show": (show: boolean) => void;
shown: () => void;
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_16<__VLS_TypePropsToRuntimeProps_31<{
element: HTMLElement | undefined;
show: boolean;
hideOnOutsideClick?: boolean | undefined;
/** If true, the width of the popover will be fixed to the width of the element. */
enforceElementWidth?: boolean | undefined;
placement?: default_3.PopoverPlacement | undefined;
}>, {
placement: string;
}>>> & {
onHide?: (() => any) | undefined;
onHidden?: (() => any) | undefined;
onShown?: (() => any) | undefined;
"onUpdate:show"?: ((show: boolean) => any) | undefined;
}, {
placement: default_3.PopoverPlacement;
}, {}>, {
    header?(_: {}): any;
    default?(_: {}): any;
}>;

export declare const PrerenderedList: DefineComponent<__VLS_TypePropsToRuntimeProps_32<{
value: string | undefined;
items: Record<string, string>;
/** If true, tabindex="-1" will be set on all elements. */
noFocus?: boolean | undefined;
}>, {
containerRef: Ref<HTMLElement | undefined>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (item: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_32<{
value: string | undefined;
items: Record<string, string>;
/** If true, tabindex="-1" will be set on all elements. */
noFocus?: boolean | undefined;
}>>> & {
onClick?: ((item: string) => any) | undefined;
}, {}, {}>;

export declare const reactiveBreakpoint: ComputedRef<"xs" | "sm" | "md" | "lg" | "xl" | "xxl">;

export declare interface RouteDestination {
    query: string;
    searchSuggestions?: SearchResult[];
    mapSuggestions?: FindOnMapResult[];
    selectedSuggestion?: SearchResult | FindOnMapResult;
}

export declare const RouteForm: DefineComponent<__VLS_WithDefaults_5<__VLS_TypePropsToRuntimeProps_9<{
/** If false, the route layer will be opaque and not draggable. */
active?: boolean | undefined;
routeId?: string | undefined;
showToolbar?: boolean | undefined;
noClear?: boolean | undefined;
}>, {
active: boolean;
showToolbar: boolean;
}>, {
setQuery: typeof setQuery;
setFrom: typeof setFrom;
addVia: typeof addVia;
setTo: typeof setTo;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
activate: () => void;
"hash-query-change": (hashQuery: HashQuery | undefined) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_5<__VLS_TypePropsToRuntimeProps_9<{
/** If false, the route layer will be opaque and not draggable. */
active?: boolean | undefined;
routeId?: string | undefined;
showToolbar?: boolean | undefined;
noClear?: boolean | undefined;
}>, {
active: boolean;
showToolbar: boolean;
}>>> & {
onActivate?: (() => any) | undefined;
"onHash-query-change"?: ((hashQuery: HashQuery | undefined) => any) | undefined;
}, {
active: boolean;
showToolbar: boolean;
}, {}>;

export declare const RouteFormTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type RouteFormTabContext = Readonly<WritableRouteFormTabContext>;

export declare const RouteMode: DefineComponent<__VLS_WithDefaults_17<__VLS_TypePropsToRuntimeProps_33<{
modelValue: RouteMode_2;
tabindex?: number | undefined;
disabled?: boolean | undefined;
tooltipPlacement?: TooltipPlacement | undefined;
}>, {
tooltipPlacement: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_17<__VLS_TypePropsToRuntimeProps_33<{
modelValue: RouteMode_2;
tabindex?: number | undefined;
disabled?: boolean | undefined;
tooltipPlacement?: TooltipPlacement | undefined;
}>, {
tooltipPlacement: string;
}>>> & {
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}, {
tooltipPlacement: TooltipPlacement;
}, {}>;

export declare const SaveViewDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

declare function search(zoom: boolean, zoomToAll?: boolean, smooth?: boolean): Promise<void>;

export declare const SearchBox: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type SearchBoxContext = DeepReadonly<WritableSearchBoxContext>;

export declare interface SearchBoxContextData {
    tabs: Map<string, SearchBoxTab_2>;
    activeTabId: string | undefined;
    activeTab: SearchBoxTab_2 | undefined;
    provideTab: (id: string, tabRef: Ref<SearchBoxTab_2>) => void;
    activateTab: (id: string, options?: {
        expand?: boolean;
        autofocus?: boolean;
    }) => void;
}

export declare type SearchBoxEventMap = {
    "resizestart": void;
    "resize": void;
    "resizeend": void;
    "resizereset": void;
};

export declare const SearchBoxTab: __VLS_WithTemplateSlots_3<DefineComponent<__VLS_TypePropsToRuntimeProps_10<{
id: string;
title: string;
isCloseable?: boolean | undefined;
hashQuery?: HashQuery | undefined;
class?: string | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_10<{
id: string;
title: string;
isCloseable?: boolean | undefined;
hashQuery?: HashQuery | undefined;
class?: string | undefined;
}>>> & {
onClose?: (() => any) | undefined;
}, {}, {}>, Readonly<{
    default(props: {
        isActive: boolean;
    }): any;
}> & {
    default(props: {
        isActive: boolean;
    }): any;
}>;

declare interface SearchBoxTab_2 {
    title: string;
    content: Slot<{
        isActive: boolean;
    }> | undefined;
    onClose?: () => void;
    hashQuery?: HashQuery;
    class?: string;
}

export declare const SearchForm: DefineComponent<    {}, {
setSearchString: typeof setSearchString;
search: typeof search;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"hash-query-change": (query: HashQuery | undefined) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
"onHash-query-change"?: ((query: HashQuery | undefined) => any) | undefined;
}, {}, {}>;

export declare const SearchFormTab: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare type SearchFormTabContext = Readonly<WritableSearchFormTabContext>;

export declare const SearchResultInfo: DefineComponent<__VLS_WithDefaults_21<__VLS_TypePropsToRuntimeProps_47<{
result: SearchResult | FileResult;
showBackButton?: boolean | undefined;
/** If specified, will be passed to the route form as suggestions when using the "Use as" menu */
searchResults?: SearchResult[] | undefined;
/** If specified, will be passed to the route form as suggestions when using the "Use as" menu */
mapResults?: FindOnMapResult[] | undefined;
isLoading?: boolean | undefined;
}>, {
showBackButton: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
back: () => void;
"add-to-map": (type: {
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_21<__VLS_TypePropsToRuntimeProps_47<{
result: SearchResult | FileResult;
showBackButton?: boolean | undefined;
/** If specified, will be passed to the route form as suggestions when using the "Use as" menu */
searchResults?: SearchResult[] | undefined;
/** If specified, will be passed to the route form as suggestions when using the "Use as" menu */
mapResults?: FindOnMapResult[] | undefined;
isLoading?: boolean | undefined;
}>, {
showBackButton: boolean;
}>>> & {
onBack?: (() => any) | undefined;
"onAdd-to-map"?: ((type: {
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}) => any) | undefined;
}, {
showBackButton: boolean;
}, {}>;

export declare const SearchResults: __VLS_WithTemplateSlots_4<DefineComponent<__VLS_WithDefaults_7<__VLS_TypePropsToRuntimeProps_12<{
searchResults?: (SearchResult | FileResult)[] | undefined;
mapResults?: FindOnMapResult[] | undefined;
layerId: number;
/** When clicking a search result, union zoom to it. Normal zoom is done when clicking the zoom button. */
unionZoom?: boolean | undefined;
/** When clicking or selecting a search result, zoom to it. */
autoZoom?: boolean | undefined;
customTypes?: Record<number, Omit<{
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}, "id" | "padId">> | undefined;
}>, {
unionZoom: boolean;
autoZoom: boolean;
customTypes: () => {};
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_7<__VLS_TypePropsToRuntimeProps_12<{
searchResults?: (SearchResult | FileResult)[] | undefined;
mapResults?: FindOnMapResult[] | undefined;
layerId: number;
/** When clicking a search result, union zoom to it. Normal zoom is done when clicking the zoom button. */
unionZoom?: boolean | undefined;
/** When clicking or selecting a search result, zoom to it. */
autoZoom?: boolean | undefined;
customTypes?: Record<number, Omit<{
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}, "id" | "padId">> | undefined;
}>, {
unionZoom: boolean;
autoZoom: boolean;
customTypes: () => {};
}>>>, {
autoZoom: boolean;
customTypes: Record<number, Omit<{
type: "marker" | "line";
id: number;
padId: string;
name: string;
idx: number;
defaultColour: string;
colourFixed: boolean;
defaultSize: number;
sizeFixed: boolean;
defaultSymbol: string;
symbolFixed: boolean;
defaultShape: string;
shapeFixed: boolean;
defaultWidth: number;
widthFixed: boolean;
defaultStroke: "" | "dashed" | "dotted";
strokeFixed: boolean;
defaultMode: string;
modeFixed: boolean;
showInLegend: boolean;
fields: {
type: "input" | "textarea" | "dropdown" | "checkbox";
name: string;
default?: string | undefined;
controlColour?: boolean | undefined;
controlSize?: boolean | undefined;
controlSymbol?: boolean | undefined;
controlShape?: boolean | undefined;
controlWidth?: boolean | undefined;
controlStroke?: boolean | undefined;
options?: {
value: string;
colour?: string | undefined;
size?: number | undefined;
symbol?: string | undefined;
shape?: string | undefined;
width?: number | undefined;
stroke?: "" | "dashed" | "dotted" | undefined;
}[] | undefined;
}[];
}, "id" | "padId">>;
unionZoom: boolean;
}, {}>, {
    before?(_: {}): any;
    after?(_: {}): any;
}>;

export declare function searchResultsToLinesWithTags(results: Array<SearchResult | FileResult>): LineWithTags[];

export declare function searchResultsToMarkersWithTags(results: Array<SearchResult | FileResult>): MarkerWithTags[];

export declare function searchResultToLineWithTags(result: SearchResult | FileResult): LineWithTags | undefined;

export declare function searchResultToMarkerWithTags(result: SearchResult | FileResult): MarkerWithTags | undefined;

declare type SearchSuggestion = SearchResult;

export declare type SelectedItem = {
    type: "marker" | "line";
    id: ID;
} | {
    type: "searchResult";
    result: SearchResult;
    layerId: number;
} | {
    type: "overpass";
    element: OverpassElement;
};

export declare class SelectionHandler extends Handler {
    _selection: Array<DeepReadonly<SelectedItem>>;
    _markersLayer: MarkersLayer;
    _linesLayer: LinesLayer;
    _searchResultLayers: SearchResultsLayer[];
    _overpassLayer: OverpassLayer;
    _boxSelectionHandler: BoxSelection;
    _selectionBeforeBox: Array<DeepReadonly<SelectedItem>>;
    _isBoxInteraction: boolean;
    _mapInteraction: number;
    _isLongClick: boolean;
    constructor(map: Map_2, markersLayer: MarkersLayer, linesLayer: LinesLayer, searchResultsLayer: SearchResultsLayer, overpassLayer: OverpassLayer);
    enable(): this;
    disable(): this;
    addHooks(): void;
    removeHooks(): void;
    addSearchResultLayer(layer: SearchResultsLayer): void;
    removeSearchResultLayer(layer: SearchResultsLayer): void;
    getSelection(): Array<DeepReadonly<SelectedItem>>;
    setSelectedItems(items: Array<DeepReadonly<SelectedItem>>, open?: boolean): void;
    isSelected(item: SelectedItem): boolean;
    selectItem(item: SelectedItem, open?: boolean): void;
    unselectItem(item: SelectedItem): void;
    toggleItem(item: SelectedItem, open?: boolean): void;
    handleClickItem(item: SelectedItem, e: LeafletEvent): void;
    handleClickMarker: (e: LeafletEvent) => void;
    handleClickLine: (e: LeafletEvent) => void;
    handleClickSearchResult: (e: LeafletEvent) => void;
    handleClickOverpass: (e: LeafletEvent) => void;
    handleClickMap: (e: LeafletEvent) => void;
    handleMapClickCapture: (e: MouseEvent) => void;
    handleMapMouseDown: (e: MouseEvent | TouchEvent) => void;
    handleMapInteractionStart: () => void;
    handleMapInteractionEnd: () => void;
    handleBoxSelectStart: (e: any) => void;
    handleBoxSelect: (e: any) => void;
    handleBoxSelectEnd: () => void;
}

export declare interface SelectionHandler extends Evented {
}

declare function setFrom(data: Parameters<typeof makeDestination>[0]): void;

declare function setQuery(query: string, zoom?: boolean, smooth?: boolean): void;

declare function setSearchString(query: string): void;

declare function setTo(data: Parameters<typeof makeDestination>[0]): void;

export declare const ShapePicker: DefineComponent<__VLS_TypePropsToRuntimeProps_34<{
modelValue: Shape;
id?: string | undefined;
validators?: Validator<string>[] | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_34<{
modelValue: Shape;
id?: string | undefined;
validators?: Validator<string>[] | undefined;
}>>> & {
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}, {}, {}>;

export declare const ShareDialog: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare function showAlert(props: Omit<AlertProps, 'type'>): Promise<void>;

export declare function showConfirm(props: Omit<AlertProps, 'type'>): Promise<boolean>;

export declare function showPrompt({ initialValue, validate, ...props }: Omit<AlertProps, 'type' | 'message'> & {
    initialValue?: string;
    /** Validate the value. Return an empty string or undefined to indicate validity. */
    validate?: (value: string) => string | undefined;
}): Promise<string | undefined>;

export declare const Sidebar: __VLS_WithTemplateSlots_14<DefineComponent<__VLS_WithDefaults_18<__VLS_TypePropsToRuntimeProps_35<{
visible?: boolean | undefined;
}>, {
visible: undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:visible": (visible: boolean) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_18<__VLS_TypePropsToRuntimeProps_35<{
visible?: boolean | undefined;
}>, {
visible: undefined;
}>>> & {
"onUpdate:visible"?: ((visible: boolean) => any) | undefined;
}, {
visible: boolean;
}, {}>, {
    default?(_: {}): any;
}>;

export declare const SizePicker: DefineComponent<__VLS_TypePropsToRuntimeProps_36<{
modelValue: number;
validators?: Validator<number>[] | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: number) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_36<{
modelValue: number;
validators?: Validator<number>[] | undefined;
}>>> & {
"onUpdate:modelValue"?: ((value: number) => any) | undefined;
}, {}, {}>;

export declare const storage: Storage_2;

declare interface Storage_2 {
    zoomToAll: boolean;
    autoZoom: boolean;
    bookmarks: Bookmark[];
}
export { Storage_2 as Storage }

export declare const StrokePicker: DefineComponent<__VLS_TypePropsToRuntimeProps_37<{
modelValue: Stroke;
validators?: Validator<"" | "dashed" | "dotted">[] | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (stroke: "" | "dashed" | "dotted") => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_37<{
modelValue: Stroke;
validators?: Validator<"" | "dashed" | "dotted">[] | undefined;
}>>> & {
"onUpdate:modelValue"?: ((stroke: "" | "dashed" | "dotted") => any) | undefined;
}, {}, {}>;

declare type Suggestion = SearchSuggestion | MapSuggestion;

export declare const SymbolPicker: DefineComponent<__VLS_TypePropsToRuntimeProps_38<{
modelValue: string;
id?: string | undefined;
validators?: Validator<string>[] | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_38<{
modelValue: string;
id?: string | undefined;
validators?: Validator<string>[] | undefined;
}>>> & {
"onUpdate:modelValue"?: ((value: string) => any) | undefined;
}, {}, {}>;

declare type SyncValidationResult = string | undefined;

/**
 * Renders a translated message. Each interpolation variable needs to be specified as a slot, making it possible to interpolate
 * components and rich text.
 */
export declare const T: DefineComponent<    {
k: {
type: StringConstructor;
required: true;
};
}, () => (string | VNode<RendererNode, RendererElement, {
[key: string]: any;
}>[])[], unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {
k: {
type: StringConstructor;
required: true;
};
}>>, {}, {}>;

export declare type ThemeColour = "primary" | "secondary" | "success" | "danger" | "warning" | "info" | "light" | "dark";

export declare const Toast: DefineComponent<__VLS_TypePropsToRuntimeProps_15<{
id: string;
title: string;
message: string | Error;
actions?: ToastAction[] | undefined;
spinner?: boolean | undefined;
variant?: ThemeColour | undefined;
noCloseButton?: boolean | undefined;
autoHide?: boolean | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
hidden: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_15<{
id: string;
title: string;
message: string | Error;
actions?: ToastAction[] | undefined;
spinner?: boolean | undefined;
variant?: ThemeColour | undefined;
noCloseButton?: boolean | undefined;
autoHide?: boolean | undefined;
}>>> & {
onHidden?: (() => any) | undefined;
}, {}, {}>;

export declare interface ToastAction {
    onClick?: (e: MouseEvent) => void;
    label: string;
    href?: string;
    variant?: ThemeColour;
    isDisabled?: boolean;
    isPending?: boolean;
}

export declare const toastContainer: HTMLDivElement;

export declare interface ToastContext {
    showErrorToast(id: string | undefined, title: string | (() => string), err: any, options?: ToastOptions | (() => ToastOptions)): Promise<void>;
    toastErrors<C extends (...args: any[]) => any>(callback: C): C;
    showToast(id: string | undefined, title: string | (() => string), message: string | (() => string), options?: ToastOptions | (() => ToastOptions)): Promise<void>;
    hideToast(id: string): Promise<void>;
    dispose(): void;
}

export declare interface ToastOptions {
    actions?: ToastAction[];
    spinner?: boolean;
    variant?: ThemeColour;
    noCloseButton?: boolean;
    autoHide?: boolean;
    onHide?: () => void;
    onHidden?: () => void;
}

export declare const Toasts: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare const Toolbox: DefineComponent<__VLS_WithDefaults_8<__VLS_TypePropsToRuntimeProps_14<{
interactive?: boolean | undefined;
}>, {
interactive: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_8<__VLS_TypePropsToRuntimeProps_14<{
interactive?: boolean | undefined;
}>, {
interactive: boolean;
}>>>, {
interactive: boolean;
}, {}>;

export declare const ToolboxAddDropdown: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"hide-sidebar": () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
"onHide-sidebar"?: (() => any) | undefined;
}, {}, {}>;

export declare const ToolboxCollabMapsDropdown: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"hide-sidebar": () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
"onHide-sidebar"?: (() => any) | undefined;
}, {}, {}>;

export declare const ToolboxHelpDropdown: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"hide-sidebar": () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
"onHide-sidebar"?: (() => any) | undefined;
}, {}, {}>;

export declare const ToolboxMapStyleDropdown: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<    {}>>, {}, {}>;

export declare const ToolboxToolsDropdown: DefineComponent<__VLS_TypePropsToRuntimeProps_13<{
interactive: boolean;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"hide-sidebar": () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_13<{
interactive: boolean;
}>>> & {
"onHide-sidebar"?: (() => any) | undefined;
}, {}, {}>;

export declare const ToolboxViewsDropdown: DefineComponent<    {}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"hide-sidebar": () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<    {}>> & {
"onHide-sidebar"?: (() => any) | undefined;
}, {}, {}>;

export declare type TooltipPlacement = "top" | "left" | "right" | "bottom";

export declare function typeExists(client: ClientContext_2, type: FileResultObject["types"][0]): boolean;

export declare const UseAsDropdown: DefineComponent<__VLS_TypePropsToRuntimeProps_39<{
destination: RouteDestination;
isDisabled?: boolean | undefined;
size?: ButtonSize | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_39<{
destination: RouteDestination;
isDisabled?: boolean | undefined;
size?: ButtonSize | undefined;
}>>>, {}, {}>;

export declare function useCarousel(element: Ref<HTMLElement | undefined>): Readonly<CarouselContext>;

export declare function useDomEventListener<Element extends EventTarget, Args extends Parameters<Element["addEventListener"]>>(element: AnyRef<EventTarget | undefined>, ...args: Args): void;

export declare function useEventListener<EventMap extends Record<string, unknown>, EventType extends keyof EventMap>(emitter: AnyRef<Emitter<EventMap> | DeepReadonly<Emitter<EventMap>> | undefined>, type: EventType, listener: (data: EventMap[EventType]) => void): void;

export declare function useI18n(): ReturnType<typeof getI18n>;

export declare function useMapContext(context: FacilMapContext, mapRef: Ref<HTMLElement>, innerContainerRef: Ref<HTMLElement>): Promise<WritableMapContext>;

/**
 * Returns a reactive boolean that is true if the current breakpoint is the specified one or smaller.
 */
export declare function useMaxBreakpoint(breakpoint: Breakpoint): Ref<boolean>;

/**
 * Returns a reactive boolean that is true if the current breakpoint is the specified one or larger.
 */
export declare function useMinBreakpoint(breakpoint: Breakpoint): Ref<boolean>;

/**
 * Enables a Bootstrap modal dialog on the element that is saved in the returned {@link ModalActions#ref}.
 */
export declare function useModal(modalRef: Ref<HTMLElement | undefined>, { onShown, onHide, onHidden, static: isStatic, noEscape }: ModalConfig): Readonly<ModalActions>;

/**
 * Registers a focus handler on the given element that does not fire when the focus was given through a click.
 */
export declare function useNonClickFocusHandler(element: AnyRef<HTMLElement | undefined>, onFocus: (e: FocusEvent) => void): void;

/**
 * Registers a click handler on the given element that does not fire when the click is caused by a drag.
 */
export declare function useNonDragClickHandler(element: AnyRef<HTMLElement | undefined>, onClick: (e: MouseEvent) => void): void;

export declare function useRefWithOverride<Value>(fallbackValue: Value, getProp: () => Value | undefined, onUpdate: (newValue: Value) => void): Ref<Value>;

export declare function useResizeObserver(element: Ref<HTMLElement | undefined>, callback?: (entry: ResizeObserverEntry) => void): DeepReadonly<Ref<ResizeObserverEntry | undefined>>;

export declare function useToasts(noScope?: boolean): ToastContext;

export declare function useUnloadHandler(hasUnsavedModifications: AnyRef<boolean>): void;

export declare function useValidatedForm(formRef: Ref<HTMLFormElement | undefined>, onSubmit: (event: CustomSubmitEvent) => void, { noValidate, formValidationError }?: {
    noValidate?: Ref<boolean>;
    /** A form validation error that will prevent the form from submitting. */
    formValidationError?: Ref<string | undefined>;
}): Readonly<ValidatedFormData>;

export declare const ValidatedField: <T>(__VLS_props: {
    value: T;
    immediate?: boolean | undefined;
    tag?: string | undefined;
    validators?: Validator<T>[] | undefined;
    reportValid?: boolean | undefined;
    debounceMs?: number | undefined;
} & VNodeProps & AllowedComponentProps & ComponentCustomProps, __VLS_ctx?: {
    slots: {
        default?(_: {
            isValidating: boolean;
            validationError: string | undefined;
            inputRef: (el: any | null) => void;
        }): any;
    };
    emit: any;
    attrs: any;
} | undefined, __VLS_expose?: ((exposed: ShallowUnwrapRef<    {}>) => void) | undefined, __VLS_setup?: Promise<{
    props: {
        value: T;
        immediate?: boolean | undefined;
        tag?: string | undefined;
        validators?: Validator<T>[] | undefined;
        reportValid?: boolean | undefined;
        debounceMs?: number | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: {
        default?(_: {
            isValidating: boolean;
            validationError: string | undefined;
            inputRef: (el: any | null) => void;
        }): any;
    };
    emit: any;
}>) => VNode<RendererNode, RendererElement, {
[key: string]: any;
}> & {
    __ctx?: {
        props: {
            value: T;
            immediate?: boolean | undefined;
            tag?: string | undefined;
            validators?: Validator<T>[] | undefined;
            reportValid?: boolean | undefined;
            debounceMs?: number | undefined;
        } & VNodeProps & AllowedComponentProps & ComponentCustomProps;
        expose(exposed: ShallowUnwrapRef<    {}>): void;
        attrs: any;
        slots: {
            default?(_: {
                isValidating: boolean;
                validationError: string | undefined;
                inputRef: (el: any | null) => void;
            }): any;
        };
        emit: any;
    } | undefined;
};

export declare const ValidatedForm: __VLS_WithTemplateSlots_5<DefineComponent<__VLS_TypePropsToRuntimeProps_16<{
action?: string | undefined;
target?: string | undefined;
noValidate?: boolean | undefined;
formValidationError?: string | undefined;
}>, {
formData: Readonly<ValidatedFormData>;
}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
submit: (event: CustomSubmitEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_16<{
action?: string | undefined;
target?: string | undefined;
noValidate?: boolean | undefined;
formValidationError?: string | undefined;
}>>> & {
onSubmit?: ((event: CustomSubmitEvent) => any) | undefined;
}, {}, {}>, {
    default?(_: {
        formData: Readonly<ValidatedFormData>;
    }): any;
}>;

export declare interface ValidatedFormData {
    isTouched: boolean;
    isSubmitting: boolean;
    isValidating: boolean;
    formValidationError: string | undefined;
    submit: () => Promise<void>;
    setValidationPromise: (element: Element, promise: Promise<any> | undefined) => void;
}

export declare function validateRequired(val: any): string | undefined;

declare type ValidationResult = SyncValidationResult | AsyncValidationResult;

export declare function validations<V>(val: V, funcs: Array<(val: V) => string | undefined>): string | undefined;

export declare type Validator<T> = (value: T, signal: AbortSignal) => ValidationResult;

export declare const vHtmlAsync: Directive<Element, Promise<string>>;

export declare function viewExists(client: ClientContext_2, view: FileResultObject["views"][0]): boolean;

export declare const vLinkDisabled: Directive<HTMLAnchorElement, boolean>;

export declare const vScrollIntoView: Directive<Element, boolean | undefined>;

export declare const vTooltip: Directive<Element, string | undefined>;

export declare const WidthPicker: DefineComponent<__VLS_TypePropsToRuntimeProps_40<{
modelValue: number;
validators?: Validator<number>[] | undefined;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"update:modelValue": (value: number) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_TypePropsToRuntimeProps_40<{
modelValue: number;
validators?: Validator<number>[] | undefined;
}>>> & {
"onUpdate:modelValue"?: ((value: number) => any) | undefined;
}, {}, {}>;

export declare interface WritableClickMarkerTabContext {
    openClickMarker(point: Point): Promise<void>;
    closeLastClickMarker(): void;
}

export declare interface WritableFacilMapContext {
    id: number;
    baseUrl: string;
    appName: string;
    hideCommercialMapLinks: boolean;
    isNarrow: boolean;
    settings: FacilMapSettings;
    components: FacilMapComponents;
    provideComponent<K extends keyof FacilMapComponents>(key: K, componentRef: Readonly<Ref<FacilMapComponents[K]>>): void;
}

export declare interface WritableImportTabContext {
    openFilePicker: () => void;
}

export declare type WritableMapContext = MapContextData & Emitter<MapContextEvents>;

export declare interface WritableRouteFormTabContext {
    setQuery(query: string, zoom?: boolean, smooth?: boolean): void;
    setFrom(destination: RouteDestination): void;
    addVia(destination: RouteDestination): void;
    setTo(destination: RouteDestination): void;
}

export declare type WritableSearchBoxContext = SearchBoxContextData & Emitter<SearchBoxEventMap>;

export declare interface WritableSearchFormTabContext {
    setQuery(query: string, zoom?: boolean, smooth?: boolean, autofocus?: boolean): Promise<void>;
}

export declare type ZoomDestination = {
    center?: LatLng;
    zoom?: number;
    bounds?: LatLngBounds;
};

export declare const ZoomToObjectButton: DefineComponent<__VLS_WithDefaults_19<__VLS_TypePropsToRuntimeProps_41<{
destination: ZoomDestination;
size?: ButtonSize | undefined;
label?: string | undefined;
}>, {
label: string;
}>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_19<__VLS_TypePropsToRuntimeProps_41<{
destination: ZoomDestination;
size?: ButtonSize | undefined;
label?: string | undefined;
}>, {
label: string;
}>>>, {
label: string;
}, {}>;

export { }


declare global {
    interface Element {
        _fmTooltip?: Tooltip;
    }
}


declare module "bootstrap" {
    interface Tooltip {
        tip: Element | null;
        _newContent: Record<string, string> | null;
    }
}