import { BaseProps } from '@phila/phila-ui-core';
import { CircleLayerSpecification } from 'maplibre-gl';
import { ColorSpecification } from 'maplibre-gl';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { DataDrivenPropertyValueSpecification } from 'maplibre-gl';
import { default as default_2 } from 'maplibre-gl';
import { DefineComponent } from 'vue';
import { ExpressionSpecification } from 'maplibre-gl';
import { ExtractPropTypes } from 'vue';
import { FillLayerSpecification } from 'maplibre-gl';
import { FilterSpecification } from 'maplibre-gl';
import { FormattedSpecification } from 'maplibre-gl';
import { GeoJSONSourceSpecification } from 'maplibre-gl';
import { IconDefinition } from '@fortawesome/free-solid-svg-icons';
import { IconDefinition as IconDefinition_2 } from '@fortawesome/fontawesome-svg-core';
import { IControl } from 'maplibre-gl';
import { LineLayerSpecification } from 'maplibre-gl';
import { LngLatLike } from 'maplibre-gl';
import { default as Map_2 } from './Map.vue';
import { MapLayerMouseEvent } from 'maplibre-gl';
import { Offset } from 'maplibre-gl';
import { PaddingSpecification } from 'maplibre-gl';
import { PointLike } from 'maplibre-gl';
import { PropertyValueSpecification } from 'maplibre-gl';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { RasterLayerSpecification } from 'maplibre-gl';
import { RasterSourceSpecification } from 'maplibre-gl';
import { Ref } from 'vue';
import { ResolvedImageSpecification } from 'maplibre-gl';
import { SymbolLayerSpecification } from 'maplibre-gl';
import { TransitionSpecification } from 'maplibre-gl';
import { VariableAnchorOffsetCollectionSpecification } from 'maplibre-gl';
import { VectorSourceSpecification } from 'maplibre-gl';
import { VisibilitySpecification } from 'maplibre-gl';

declare const __VLS_component: DefineComponent<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MapMarkerProps>, {
color: string;
popup: undefined;
draggable: boolean;
rotation: number;
offset: undefined;
icon: undefined;
iconSize: number;
iconColor: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
dragstart: (lngLat: {
lng: number;
lat: number;
}) => void;
drag: (lngLat: {
lng: number;
lat: number;
}) => void;
dragend: (lngLat: {
lng: number;
lat: number;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<MapMarkerProps>, {
color: string;
popup: undefined;
draggable: boolean;
rotation: number;
offset: undefined;
icon: undefined;
iconSize: number;
iconColor: undefined;
}>>> & Readonly<{
onDrag?: ((lngLat: {
lng: number;
lat: number;
}) => any) | undefined;
onDragend?: ((lngLat: {
lng: number;
lat: number;
}) => any) | undefined;
onDragstart?: ((lngLat: {
lng: number;
lat: number;
}) => any) | undefined;
}>, {
icon: string;
iconSize: number;
offset: default_2.PointLike;
rotation: number;
color: string;
popup: string;
draggable: boolean;
iconColor: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_2: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<MapPopupProps>, {
html: undefined;
closeButton: boolean;
closeOnClick: boolean;
className: undefined;
maxWidth: string;
offset: undefined;
anchor: undefined;
showNavigation: boolean;
currentFeatureIndex: number;
totalFeatures: number;
layerName: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
close: () => void;
open: () => void;
next: () => void;
previous: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_2<__VLS_TypePropsToRuntimeProps_2<MapPopupProps>, {
html: undefined;
closeButton: boolean;
closeOnClick: boolean;
className: undefined;
maxWidth: string;
offset: undefined;
anchor: undefined;
showNavigation: boolean;
currentFeatureIndex: number;
totalFeatures: number;
layerName: undefined;
}>>> & Readonly<{
onClose?: (() => any) | undefined;
onOpen?: (() => any) | undefined;
onNext?: (() => any) | undefined;
onPrevious?: (() => any) | undefined;
}>, {
offset: default_2.Offset;
className: string;
anchor: "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "center";
html: string;
closeButton: boolean;
closeOnClick: boolean;
maxWidth: string;
showNavigation: boolean;
currentFeatureIndex: number;
totalFeatures: number;
layerName: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_3: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_8<__VLS_TypePropsToRuntimeProps_8<MapNavigationControlProps>, {
position: string;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_8<__VLS_TypePropsToRuntimeProps_8<MapNavigationControlProps>, {
position: string;
}>>> & Readonly<{}>, {
position: MapControlPosition_2;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_4: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_9<__VLS_TypePropsToRuntimeProps_9<MapFloatingPanelProps>, {
position: string;
visible: boolean;
offset: () => {
x: number;
y: number;
};
leaveRoomForControls: boolean;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_9<__VLS_TypePropsToRuntimeProps_9<MapFloatingPanelProps>, {
position: string;
visible: boolean;
offset: () => {
x: number;
y: number;
};
leaveRoomForControls: boolean;
}>>> & Readonly<{}>, {
position: MapControlPosition_2;
visible: boolean;
offset: {
x: number;
y: number;
};
leaveRoomForControls: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_5: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_11<__VLS_TypePropsToRuntimeProps_11<MapButtonProps>, {
icon: undefined;
image: string;
position: string;
title: string;
iconSize: number;
toggleable: boolean;
active: boolean;
activeColor: string;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: () => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_11<__VLS_TypePropsToRuntimeProps_11<MapButtonProps>, {
icon: undefined;
image: string;
position: string;
title: string;
iconSize: number;
toggleable: boolean;
active: boolean;
activeColor: string;
}>>> & Readonly<{
onClick?: (() => any) | undefined;
}>, {
icon: IconDefinition_2 | string;
image: string;
position: MapControlPosition_2;
title: string;
iconSize: number;
toggleable: boolean;
active: boolean;
activeColor: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare const __VLS_component_6: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_18<__VLS_TypePropsToRuntimeProps_18<CyclomediaRecordingsLayerProps>, {
config: undefined;
visible: boolean;
year: undefined;
autoFetch: boolean;
selectedRecordingId: undefined;
minZoom: number;
maxZoom: undefined;
}>>, {
fetchRecordings: typeof fetchRecordingsForBounds;
clearRecordings: () => void;
recordings: ComputedRef<CyclomediaRecording[]>;
isLoading: ComputedRef<boolean>;
error: ComputedRef<CyclomediaError | null>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"recording-click": (recording: CyclomediaRecording) => void;
"recordings-loaded": (count: number) => void;
error: (error: {
message: string;
type: string;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_18<__VLS_TypePropsToRuntimeProps_18<CyclomediaRecordingsLayerProps>, {
config: undefined;
visible: boolean;
year: undefined;
autoFetch: boolean;
selectedRecordingId: undefined;
minZoom: number;
maxZoom: undefined;
}>>> & Readonly<{
onError?: ((error: {
message: string;
type: string;
}) => any) | undefined;
"onRecording-click"?: ((recording: CyclomediaRecording) => any) | undefined;
"onRecordings-loaded"?: ((count: number) => any) | undefined;
}>, {
visible: boolean;
year: number;
minZoom: number;
maxZoom: number;
config: RecordingsClientConfig;
autoFetch: boolean;
selectedRecordingId: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

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_3<T> = T extends undefined ? never : T;

declare type __VLS_NonUndefinedable_4<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_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 function __VLS_template(): {
    default?(_: {}): any;
};

declare function __VLS_template_2(): {
    default?(_: {}): any;
};

declare function __VLS_template_3(): {
    default?(_: {}): any;
};

declare function __VLS_template_4(): {
    default?(_: {}): any;
};

declare function __VLS_template_5(): {
    default?(_: {}): any;
};

declare function __VLS_template_6(): {
    default?(_: {}): any;
};

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_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_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_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_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_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;
    };
};

/** AIS geocode result feature */
export declare interface AisGeocodeResult {
    type: "Feature";
    ais_feature_type: string;
    match_type: string;
    geometry: {
        type: "Point";
        coordinates: [number, number];
    };
    properties: {
        street_address: string;
        opa_account_num?: string;
        opa_owners?: string[];
        zip_code?: string;
        pwd_parcel_id?: string;
        [key: string]: unknown;
    };
}

/** Full AIS API response */
export declare interface AisResponse {
    search_type: string;
    search_params: {
        query: string;
        [key: string]: unknown;
    };
    query: string;
    normalized: string;
    page: number;
    page_count: number;
    page_size: number;
    total_size: number;
    type: "FeatureCollection";
    features: AisGeocodeResult[];
}

/** Base props shared by all vector layer components */
declare interface BaseLayerProps extends BaseProps {
    /** Unique layer ID */
    id: string;
    /** Layer source - either inline definition or reference to existing source ID */
    source: string | GeoJSONSourceSpecification | VectorSourceSpecification;
    /** Source layer (for vector tile sources) */
    sourceLayer?: string;
    /** Filter expression to filter features */
    filter?: FilterSpecification;
    /** Minimum zoom level for layer visibility */
    minzoom?: number;
    /** Maximum zoom level for layer visibility */
    maxzoom?: number;
    /** ID of layer to insert this layer before */
    beforeId?: string;
}

declare interface BasemapChangeEvent {
    showImagery: boolean;
    imageryUrl: string | null;
    imageryLabelsUrl: string | null;
    /** Whether labels should be shown for the selected imagery. False for historic maps with built-in labels. */
    showLabels: boolean;
}

export declare const BasemapDropdown: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_14<__VLS_TypePropsToRuntimeProps_14<BasemapDropdownProps>, {
position: string;
selectedIndex: number;
useAsControl: boolean;
isDropUp: boolean;
}>>, {
isOpen: Ref<boolean, boolean>;
selectedIndex: Ref<number, number>;
selectedOption: ComputedRef<BasemapOption>;
toggleDropdown: typeof toggleDropdown;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
select: (option: BasemapOption, index: number) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_14<__VLS_TypePropsToRuntimeProps_14<BasemapDropdownProps>, {
position: string;
selectedIndex: number;
useAsControl: boolean;
isDropUp: boolean;
}>>> & Readonly<{
onSelect?: ((option: BasemapOption, index: number) => any) | undefined;
}>, {
position: MapControlPosition_2;
selectedIndex: number;
useAsControl: boolean;
isDropUp: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface BasemapDropdownProps {
    options: BasemapOption[];
    position?: MapControlPosition_2;
    selectedIndex?: number;
    useAsControl?: boolean;
    isDropUp?: boolean;
}

declare interface BasemapOption {
    label: string;
    imageryUrl: string;
    imageryLabelsUrl: string | null;
    /** Whether labels should be shown for this option. False for historic maps with built-in labels. */
    showLabels?: boolean;
}

export declare const BasemapToggle: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_13<__VLS_TypePropsToRuntimeProps_13<BasemapToggleProps>, {
position: string;
imageryUrl: string;
imageryLabelsUrl: string;
title: string;
iconSize: number;
showDropdown: boolean;
dropdownOptions: () => ImageryYearOption[];
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
change: (value: BasemapChangeEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_13<__VLS_TypePropsToRuntimeProps_13<BasemapToggleProps>, {
position: string;
imageryUrl: string;
imageryLabelsUrl: string;
title: string;
iconSize: number;
showDropdown: boolean;
dropdownOptions: () => ImageryYearOption[];
}>>> & Readonly<{
onChange?: ((value: BasemapChangeEvent) => any) | undefined;
}>, {
position: MapControlPosition_2;
title: string;
iconSize: number;
imageryUrl: string;
imageryLabelsUrl: string;
showDropdown: boolean;
dropdownOptions: BasemapOption[];
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface BasemapToggleProps extends BaseProps {
    position?: MapControlPosition_2;
    imageryUrl?: string;
    imageryLabelsUrl?: string;
    iconImage?: string | null;
    basemapImage?: string | null;
    title?: string;
    iconSize?: number;
    showDropdown?: boolean;
    dropdownOptions?: BasemapOption[];
}

/**
 * Bounding box for querying recordings
 */
export declare interface BoundingBox {
    /** Minimum longitude */
    minLng: number;
    /** Minimum latitude */
    minLat: number;
    /** Maximum longitude */
    maxLng: number;
    /** Maximum latitude */
    maxLat: number;
}

/**
 * Camera position information from the viewer
 */
export declare interface CameraPosition {
    /** Longitude */
    lng: number;
    /** Latitude */
    lat: number;
    /** Height/elevation */
    height?: number;
    /** Yaw (horizontal rotation) in degrees */
    yaw?: number;
    /** Pitch (vertical rotation) in degrees */
    pitch?: number;
    /** Horizontal field of view in degrees */
    hFov?: number;
    /** Roll rotation in degrees */
    roll?: number;
}

export declare const CircleLayer: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_5<__VLS_TypePropsToRuntimeProps_5<CircleLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: MapLayerMouseEvent) => void;
dblclick: (event: MapLayerMouseEvent) => void;
mouseenter: (event: MapLayerMouseEvent) => void;
mouseleave: (event: MapLayerMouseEvent) => void;
mousemove: (event: MapLayerMouseEvent) => void;
mousedown: (event: MapLayerMouseEvent) => void;
mouseup: (event: MapLayerMouseEvent) => void;
contextmenu: (event: MapLayerMouseEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_5<__VLS_TypePropsToRuntimeProps_5<CircleLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>> & Readonly<{
onClick?: ((event: MapLayerMouseEvent) => any) | undefined;
onDblclick?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousedown?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseup?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousemove?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseenter?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseleave?: ((event: MapLayerMouseEvent) => any) | undefined;
onContextmenu?: ((event: MapLayerMouseEvent) => any) | undefined;
}>, {
sourceLayer: string;
filter: FilterSpecification;
minzoom: number;
maxzoom: number;
beforeId: string;
paint: {
"circle-radius"?: DataDrivenPropertyValueSpecification<number>;
"circle-radius-transition"?: TransitionSpecification;
"circle-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"circle-color-transition"?: TransitionSpecification;
"circle-blur"?: DataDrivenPropertyValueSpecification<number>;
"circle-blur-transition"?: TransitionSpecification;
"circle-opacity"?: DataDrivenPropertyValueSpecification<number>;
"circle-opacity-transition"?: TransitionSpecification;
"circle-translate"?: PropertyValueSpecification<[number, number]>;
"circle-translate-transition"?: TransitionSpecification;
"circle-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
"circle-pitch-scale"?: PropertyValueSpecification<"map" | "viewport">;
"circle-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport">;
"circle-stroke-width"?: DataDrivenPropertyValueSpecification<number>;
"circle-stroke-width-transition"?: TransitionSpecification;
"circle-stroke-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"circle-stroke-color-transition"?: TransitionSpecification;
"circle-stroke-opacity"?: DataDrivenPropertyValueSpecification<number>;
"circle-stroke-opacity-transition"?: TransitionSpecification;
};
layout: {
"circle-sort-key"?: DataDrivenPropertyValueSpecification<number>;
visibility?: VisibilitySpecification;
};
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface CircleLayerProps extends BaseLayerProps {
    /** Paint properties for circle styling */
    paint?: CircleLayerSpecification["paint"];
    /** Layout properties */
    layout?: CircleLayerSpecification["layout"];
}

/**
 * Clear the cached token (useful for logout or error recovery)
 */
export declare function clearTokenCache(): void;

export declare const CyclomediaButton: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_16<__VLS_TypePropsToRuntimeProps_16<CyclomediaButtonProps>, {
position: string;
iconSize: number;
title: string;
active: boolean;
disabled: boolean;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
toggle: (data: {
active: boolean;
location: {
lat: number;
lng: number;
};
}) => void;
error: (error: Error) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_16<__VLS_TypePropsToRuntimeProps_16<CyclomediaButtonProps>, {
position: string;
iconSize: number;
title: string;
active: boolean;
disabled: boolean;
}>>> & Readonly<{
onError?: ((error: Error) => any) | undefined;
onToggle?: ((data: {
active: boolean;
location: {
lat: number;
lng: number;
};
}) => any) | undefined;
}>, {
position: MapControlPosition;
title: string;
iconSize: number;
active: boolean;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Emits for CyclomediaButton component
 */
export declare interface CyclomediaButtonEmits {
    /**
     * Fired when button is toggled
     * @param data - Contains active state and current map location
     */
    (e: "toggle", data: {
        active: boolean;
        location: {
            lat: number;
            lng: number;
        };
    }): void;
    /**
     * Fired when an error occurs
     * @param error - The error that occurred
     */
    (e: "error", error: Error): void;
}

/**
 * Props for CyclomediaButton component
 */
export declare interface CyclomediaButtonProps {
    /** Position of the button on the map */
    position?: MapControlPosition;
    /** Optional FontAwesome icon (alternative to image) */
    icon?: string;
    /** Optional image URL (default: cyclomedia.png) */
    image?: string;
    /** Size of the icon in pixels */
    iconSize?: number;
    /** Tooltip title for the button */
    title?: string;
    /** Whether the button is in active state (controlled) */
    active?: boolean;
    /** Whether the button is disabled */
    disabled?: boolean;
}

/**
 * State management for Cyclomedia composable
 */
export declare interface CyclomediaComposableState {
    /** Whether the viewer is active */
    isActive: boolean;
    /** Whether the API is initialized */
    isInitialized: boolean;
    /** Whether the viewer is currently loading */
    isLoading: boolean;
    /** Current camera position */
    cameraPosition: CameraPosition | null;
    /** Current year filter */
    currentYear: number | null;
    /** Current error state */
    error: CyclomediaError | null;
    /** Current viewer state */
    viewerState: CyclomediaViewerState | null;
}

/**
 * Configuration for initializing the Cyclomedia Street Smart API
 */
export declare interface CyclomediaConfig {
    /** Username for Street Smart API authentication */
    username: string;
    /** Password for Street Smart API authentication */
    password: string;
    /** API key for Street Smart API authentication */
    apiKey: string;
    /** Spatial Reference System (e.g., 'EPSG:4326') */
    srs: string;
    /** Locale for the viewer UI (must be a valid Cyclomedia locale) */
    locale?: CyclomediaLocale;
    /** Additional configuration options */
    addressSettings?: {
        locale: string;
        database: string;
    };
    /** Configuration for panorama viewer */
    panoramaViewer?: {
        replace?: boolean;
        srs?: string;
        closable?: boolean;
        maximizable?: boolean;
        timeTravelVisible?: boolean;
        navbarVisible?: boolean;
        [key: string]: unknown;
    };
}

/**
 * Error information from the Cyclomedia API
 */
export declare interface CyclomediaError {
    /** Error message */
    message: string;
    /** Error code */
    code?: string | number;
    /** Error type */
    type?: string;
    /** Additional error details */
    details?: unknown;
}

/**
 * Cyclomedia Street Smart API event types
 */
declare enum CyclomediaEvents {
    /** Fired when the view changes (rotation, zoom, etc.) */
    VIEW_CHANGE = "VIEW_CHANGE",
    /** Fired when a view has finished loading */
    VIEW_LOAD_END = "VIEW_LOAD_END",
    /** Fired when the API is ready to use */
    API_READY = "API_READY",
    /** Fired when an error occurs */
    ERROR = "ERROR",
    /** Fired when a measurement is created */
    MEASUREMENT_CHANGED = "MEASUREMENT_CHANGED",
    /** Fired when imagery is clicked */
    IMAGE_CLICKED = "IMAGE_CLICKED",
    /** Fired when the recording changes */
    RECORDING_CHANGED = "RECORDING_CHANGED"
}

/**
 * TypeScript type definitions for Cyclomedia Street Smart API integration
 * Based on @cyclomedia/streetsmart-api package
 *
 * ## Design Decisions
 *
 * ### Separate Type File
 * Types are in their own file (not co-located with components) because:
 * 1. Types are shared across multiple components and composables
 * 2. Avoids circular dependency issues between files
 * 3. Makes types easy to find and import
 * 4. Exported from package for consumer type checking
 *
 * ### CyclomediaConfig vs RecordingsClientConfig
 * Two separate config types exist because:
 * 1. Street Smart API (viewer) and WFS API (recordings) have different auth patterns
 * 2. Street Smart uses username/password/apiKey
 * 3. WFS uses Basic auth with username/password only
 * 4. RecordingsClientConfig also has WFS-specific options (typeName, maxFeatures)
 *
 * ### CameraPosition Fields
 * Position includes yaw/pitch/hFov/roll because:
 * 1. Cyclomedia viewer reports full 6DOF camera state
 * 2. yaw/pitch used for icon rotation on map
 * 3. hFov used for viewcone triangle angle
 * 4. All fields optional since some events only report partial state
 *
 * @module cyclomedia/types
 */
/**
 * Supported locale values for the Cyclomedia Street Smart API
 * Must match the Locale type from @cyclomedia/streetsmart-api
 */
declare type CyclomediaLocale = "de" | "en-GB" | "en-US" | "fi" | "fr" | "nl" | "tr" | "pl" | "es-ES" | "eu-ES" | "ca-ES";

export declare const CyclomediaPanel: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_17<__VLS_TypePropsToRuntimeProps_17<CyclomediaPanelProps>, {
year: undefined;
autoOpen: boolean;
popOutEnabled: boolean;
}>>, {
initializeViewer: typeof initializeViewer;
updateLocation: (coords: {
lng: number;
lat: number;
}, year?: number) => Promise<void>;
isActive: ComputedRef<boolean>;
isLoading: ComputedRef<boolean>;
error: ComputedRef<CyclomediaError | null>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
"view-change": (cameraPosition: CameraPosition) => void;
"location-change": (location: {
lng: number;
lat: number;
}) => void;
"year-change": (year: number) => void;
ready: () => void;
error: (error: {
message: string;
type: string;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_17<__VLS_TypePropsToRuntimeProps_17<CyclomediaPanelProps>, {
year: undefined;
autoOpen: boolean;
popOutEnabled: boolean;
}>>> & Readonly<{
onError?: ((error: {
message: string;
type: string;
}) => any) | undefined;
onReady?: (() => any) | undefined;
"onView-change"?: ((cameraPosition: CameraPosition) => any) | undefined;
"onLocation-change"?: ((location: {
lng: number;
lat: number;
}) => any) | undefined;
"onYear-change"?: ((year: number) => any) | undefined;
}>, {
year: number;
autoOpen: boolean;
popOutEnabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Configuration for the Cyclomedia panel component
 */
export declare interface CyclomediaPanelConfig {
    /** API configuration */
    apiConfig: CyclomediaConfig;
    /** Recordings client configuration */
    recordingsConfig?: RecordingsClientConfig;
    /** Whether to automatically open the viewer */
    autoOpen?: boolean;
    /** Whether to enable pop-out functionality */
    popOutEnabled?: boolean;
    /** Initial location to display */
    initialLocation?: {
        lng: number;
        lat: number;
    };
    /** Initial year filter */
    initialYear?: number;
}

/**
 * Props for CyclomediaPanel component
 */
declare interface CyclomediaPanelProps {
    /** Optional year filter for imagery */
    year?: number;
    /** Whether to automatically open viewer on mount */
    autoOpen?: boolean;
    /** Whether to show pop-out button */
    popOutEnabled?: boolean;
}

/**
 * Represents a single Cyclomedia recording (available imagery location)
 */
export declare interface CyclomediaRecording {
    /** Unique identifier for the image */
    imageId: string;
    /** Longitude coordinate */
    lng: number;
    /** Latitude coordinate */
    lat: number;
    /** Year the image was captured */
    year: number;
    /** Expiration date of the recording */
    expiredAt?: Date;
    /** Recording date */
    recordedAt?: Date;
    /** Height of the recording point */
    height?: number;
    /** Optional product type */
    productType?: string;
    /** Optional additional properties */
    [key: string]: unknown;
}

export declare const CyclomediaRecordingsLayer: __VLS_WithTemplateSlots_6<typeof __VLS_component_6, ReturnType<typeof __VLS_template_6>>;

/**
 * Props for CyclomediaRecordingsLayer component
 */
declare interface CyclomediaRecordingsLayerProps {
    /** Configuration for the recordings WFS service */
    config?: RecordingsClientConfig;
    /** Whether the layer is visible */
    visible?: boolean;
    /** Optional year filter for recordings */
    year?: number;
    /** Whether to automatically fetch recordings when map bounds change */
    autoFetch?: boolean;
    /** ID of the currently selected recording (for styling) */
    selectedRecordingId?: string;
    /** Minimum zoom level for visibility */
    minZoom?: number;
    /** Maximum zoom level for visibility */
    maxZoom?: number;
}

/**
 * Current state of the Cyclomedia panorama viewer
 */
export declare interface CyclomediaViewerState {
    /** Whether the viewer is currently active */
    active: boolean;
    /** Horizontal field of view in degrees */
    hFov?: number;
    /** Yaw (horizontal rotation) in degrees */
    yaw?: number;
    /** Pitch (vertical rotation) in degrees */
    pitch?: number;
    /** X coordinate in the specified SRS */
    x?: number;
    /** Y coordinate in the specified SRS */
    y?: number;
    /** Z coordinate (height/elevation) */
    z?: number;
    /** Longitude coordinate */
    lng?: number;
    /** Latitude coordinate */
    lat?: number;
    /** Year of currently displayed imagery */
    year?: number;
    /** Current recording ID being viewed */
    recordingId?: string;
}

export declare const defaultBasemapSource: RasterSourceSpecification;

export declare const defaultImageryOptions: ImageryYearOption[];

export declare const defaultLabelsSource: RasterSourceSpecification;

export declare const DrawTool: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_10<__VLS_TypePropsToRuntimeProps_10<DrawToolProps>, {
position: string;
title: string;
iconSize: number;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
polygonComplete: (geometry: ShapeGeometry) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_10<__VLS_TypePropsToRuntimeProps_10<DrawToolProps>, {
position: string;
title: string;
iconSize: number;
}>>> & Readonly<{
onPolygonComplete?: ((geometry: ShapeGeometry) => any) | undefined;
}>, {
position: MapControlPosition_2;
title: string;
iconSize: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface DrawToolProps extends BaseProps {
    icon?: IconDefinition | string;
    position?: MapControlPosition_2;
    title?: string;
    iconSize?: number;
}

/**
 * Fetch the geometry for a parcel by its ID.
 * Returns a GeoJSON FeatureCollection, or null if not found.
 */
export declare function fetchParcelGeometry(parcelId: string): Promise<ParcelFeatureCollection | null>;

/**
 * Fetch recordings for current map bounds
 */
declare function fetchRecordingsForBounds(): Promise<void>;

export declare const FillLayer: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<FillLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: MapLayerMouseEvent) => void;
dblclick: (event: MapLayerMouseEvent) => void;
mouseenter: (event: MapLayerMouseEvent) => void;
mouseleave: (event: MapLayerMouseEvent) => void;
mousemove: (event: MapLayerMouseEvent) => void;
mousedown: (event: MapLayerMouseEvent) => void;
mouseup: (event: MapLayerMouseEvent) => void;
contextmenu: (event: MapLayerMouseEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_3<__VLS_TypePropsToRuntimeProps_3<FillLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>> & Readonly<{
onClick?: ((event: MapLayerMouseEvent) => any) | undefined;
onDblclick?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousedown?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseup?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousemove?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseenter?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseleave?: ((event: MapLayerMouseEvent) => any) | undefined;
onContextmenu?: ((event: MapLayerMouseEvent) => any) | undefined;
}>, {
sourceLayer: string;
filter: FilterSpecification;
minzoom: number;
maxzoom: number;
beforeId: string;
paint: {
"fill-antialias"?: PropertyValueSpecification<boolean>;
"fill-opacity"?: DataDrivenPropertyValueSpecification<number>;
"fill-opacity-transition"?: TransitionSpecification;
"fill-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"fill-color-transition"?: TransitionSpecification;
"fill-outline-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"fill-outline-color-transition"?: TransitionSpecification;
"fill-translate"?: PropertyValueSpecification<[number, number]>;
"fill-translate-transition"?: TransitionSpecification;
"fill-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
"fill-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
"fill-pattern-transition"?: TransitionSpecification;
};
layout: {
"fill-sort-key"?: DataDrivenPropertyValueSpecification<number>;
visibility?: VisibilitySpecification;
};
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface FillLayerProps extends BaseLayerProps {
    /** Paint properties for fill styling */
    paint?: FillLayerSpecification["paint"];
    /** Layout properties */
    layout?: FillLayerSpecification["layout"];
}

/**
 * Geocode an address string via Philadelphia AIS API.
 * Returns the full AIS response object, or null if no results found.
 */
export declare function geocodeAddress(address: string): Promise<AisResponse | null>;

export declare const GeolocationButton: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_12<__VLS_TypePropsToRuntimeProps_12<GeolocationButtonProps>, {
position: string;
iconSize: number;
title: string;
trackUser: boolean;
markerColor: string;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
located: (data: {
longitude: number;
latitude: number;
accuracy: number;
}) => void;
error: (error: Error | GeolocationPositionError) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_12<__VLS_TypePropsToRuntimeProps_12<GeolocationButtonProps>, {
position: string;
iconSize: number;
title: string;
trackUser: boolean;
markerColor: string;
}>>> & Readonly<{
onLocated?: ((data: {
longitude: number;
latitude: number;
accuracy: number;
}) => any) | undefined;
onError?: ((error: Error | GeolocationPositionError) => any) | undefined;
}>, {
position: MapControlPosition_2;
title: string;
iconSize: number;
trackUser: boolean;
markerColor: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface GeolocationButtonProps extends BaseProps {
    position?: MapControlPosition_2;
    icon?: IconDefinition | string;
    iconSize?: number;
    title?: string;
    trackUser?: boolean;
    markerColor?: string;
}

/**
 * Get a valid access token, using cache if available and not expired
 *
 * @param config - Authentication configuration
 * @returns Valid access token string
 * @throws Error on authentication failure
 */
export declare function getValidToken(config: PictometryAuthConfig): Promise<string>;

export declare const imageryLabelsSource: RasterSourceSpecification;

export declare const imageryLabelsUrl = "https://tiles.arcgis.com/tiles/fLeGjb7u4uXqeF9q/arcgis/rest/services/CityImagery_Labels/MapServer/tile/{z}/{y}/{x}";

export declare const imageryParcelOutlinesSource: RasterSourceSpecification;

export declare interface ImagerySource {
    tiles: string[];
    type: "raster";
    tileSize: number;
}

export declare const imagerySources: Record<string, RasterSourceSpecification>;

export declare interface ImageryYearOption {
    label: string;
    year: string;
    imageryUrl: string;
    imageryLabelsUrl: string | null;
    /** Whether labels should be shown for this imagery year. True for actual aerial imagery, false for historic maps with built-in labels. */
    showLabels: boolean;
}

/**
 * Initialize the Street Smart viewer
 */
declare function initializeViewer(): Promise<void>;

/**
 * Initialize the Pictometry viewer
 */
declare function initializeViewer_2(): Promise<void>;

/**
 * Check if the Pictometry SDK is already loaded
 *
 * @returns True if window.ev.EmbeddedExplorer exists
 */
export declare function isPictometryLoaded(): boolean;

export declare const LineLayer: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_4<LineLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: MapLayerMouseEvent) => void;
dblclick: (event: MapLayerMouseEvent) => void;
mouseenter: (event: MapLayerMouseEvent) => void;
mouseleave: (event: MapLayerMouseEvent) => void;
mousemove: (event: MapLayerMouseEvent) => void;
mousedown: (event: MapLayerMouseEvent) => void;
mouseup: (event: MapLayerMouseEvent) => void;
contextmenu: (event: MapLayerMouseEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_4<__VLS_TypePropsToRuntimeProps_4<LineLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>> & Readonly<{
onClick?: ((event: MapLayerMouseEvent) => any) | undefined;
onDblclick?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousedown?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseup?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousemove?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseenter?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseleave?: ((event: MapLayerMouseEvent) => any) | undefined;
onContextmenu?: ((event: MapLayerMouseEvent) => any) | undefined;
}>, {
sourceLayer: string;
filter: FilterSpecification;
minzoom: number;
maxzoom: number;
beforeId: string;
paint: {
"line-opacity"?: DataDrivenPropertyValueSpecification<number>;
"line-opacity-transition"?: TransitionSpecification;
"line-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"line-color-transition"?: TransitionSpecification;
"line-translate"?: PropertyValueSpecification<[number, number]>;
"line-translate-transition"?: TransitionSpecification;
"line-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
"line-width"?: DataDrivenPropertyValueSpecification<number>;
"line-width-transition"?: TransitionSpecification;
"line-gap-width"?: DataDrivenPropertyValueSpecification<number>;
"line-gap-width-transition"?: TransitionSpecification;
"line-offset"?: DataDrivenPropertyValueSpecification<number>;
"line-offset-transition"?: TransitionSpecification;
"line-blur"?: DataDrivenPropertyValueSpecification<number>;
"line-blur-transition"?: TransitionSpecification;
"line-dasharray"?: DataDrivenPropertyValueSpecification<Array<number>>;
"line-dasharray-transition"?: TransitionSpecification;
"line-pattern"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
"line-pattern-transition"?: TransitionSpecification;
"line-gradient"?: ExpressionSpecification;
};
layout: {
"line-cap"?: PropertyValueSpecification<"butt" | "round" | "square">;
"line-join"?: DataDrivenPropertyValueSpecification<"bevel" | "round" | "miter">;
"line-miter-limit"?: PropertyValueSpecification<number>;
"line-round-limit"?: PropertyValueSpecification<number>;
"line-sort-key"?: DataDrivenPropertyValueSpecification<number>;
visibility?: VisibilitySpecification;
};
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface LineLayerProps extends BaseLayerProps {
    /** Paint properties for line styling */
    paint?: LineLayerSpecification["paint"];
    /** Layout properties */
    layout?: LineLayerSpecification["layout"];
}

declare interface LineStringGeometry {
    type: "LineString";
    coordinates: number[][];
}

/**
 * Load the Pictometry SDK script from CDN
 *
 * @param sdkUrl - Optional custom SDK URL (for versioning/testing)
 * @returns Promise that resolves when SDK is ready
 * @throws PictometryError on load failure
 */
export declare function loadPictometryScript(sdkUrl?: string): Promise<void>;

export { Map_2 as Map }

export declare const MapButton: __VLS_WithTemplateSlots_5<typeof __VLS_component_5, ReturnType<typeof __VLS_template_5>>;

declare interface MapButtonProps extends BaseProps {
    icon?: IconDefinition | string;
    image?: string;
    position?: MapControlPosition_2;
    title?: string;
    iconSize?: number;
    toggleable?: boolean;
    active?: boolean;
    activeColor?: string;
}

/**
 * Map control position type
 */
export declare type MapControlPosition = "top-left" | "top-right" | "bottom-left" | "bottom-right";

/** Common position type for map controls */
declare type MapControlPosition_2 = "top-left" | "top-right" | "bottom-left" | "bottom-right";

/**
 * Control position options (same as map controls)
 */
declare type MapControlPosition_3 = "top-left" | "top-right" | "bottom-left" | "bottom-right";

export declare const MapFloatingPanel: __VLS_WithTemplateSlots_4<typeof __VLS_component_4, ReturnType<typeof __VLS_template_4>>;

declare interface MapFloatingPanelProps extends BaseProps {
    position?: MapControlPosition_2;
    visible?: boolean;
    offset?: {
        x: number;
        y: number;
    };
    leaveRoomForControls?: boolean;
}

export declare const MapMarker: __VLS_WithTemplateSlots<typeof __VLS_component, ReturnType<typeof __VLS_template>>;

export declare interface MapMarkerEmits {
    (e: "dragstart", lngLat: {
        lng: number;
        lat: number;
    }): void;
    (e: "drag", lngLat: {
        lng: number;
        lat: number;
    }): void;
    (e: "dragend", lngLat: {
        lng: number;
        lat: number;
    }): void;
}

export declare interface MapMarkerProps extends BaseProps {
    /** The longitude and latitude of the marker position. Set to null to hide the marker. */
    lngLat: [number, number] | null;
    /** The color of the marker (default: "#FF0000") */
    color?: string;
    popup?: string;
    draggable?: boolean;
    rotation?: number;
    offset?: PointLike;
    icon?: string;
    iconSize?: number;
    iconColor?: string;
}

export declare const MapNavigationControl: __VLS_WithTemplateSlots_3<typeof __VLS_component_3, ReturnType<typeof __VLS_template_3>>;

declare interface MapNavigationControlProps extends BaseProps {
    position?: MapControlPosition_2;
}

export declare const MapPopup: __VLS_WithTemplateSlots_2<typeof __VLS_component_2, ReturnType<typeof __VLS_template_2>>;

declare interface MapPopupProps {
    /** The geographic location for the popup [lng, lat] */
    lngLat: LngLatLike;
    /** HTML content to display in the popup */
    html?: string;
    /** Whether the popup should have a close button */
    closeButton?: boolean;
    /** Whether clicking outside the popup closes it */
    closeOnClick?: boolean;
    /** CSS class name(s) to add to the popup container */
    className?: string;
    /** Maximum width of the popup (CSS string, e.g., '300px') */
    maxWidth?: string;
    /** Offset from the anchor point [x, y] pixels */
    offset?: Offset;
    /** Anchor position relative to the lngLat */
    anchor?: "top" | "bottom" | "left" | "right" | "top-left" | "top-right" | "bottom-left" | "bottom-right" | "center";
    /** Whether to show navigation controls for multi-feature popups */
    showNavigation?: boolean;
    /** Current feature index (0-based) for navigation */
    currentFeatureIndex?: number;
    /** Total number of features available for navigation */
    totalFeatures?: number;
    /** Layer name to display in popup header */
    layerName?: string;
}

export declare const MapSearchControl: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_15<__VLS_TypePropsToRuntimeProps_15<MapSearchControlProps>, {
position: string;
placeholder: string;
geocode: boolean;
flyTo: boolean;
flyToZoom: number;
}>>, {
loading: Ref<boolean, boolean>;
error: Ref<string | null, string | null>;
searchQuery: Ref<string, string>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
search: (query: string) => void;
result: (result: AisGeocodeResult) => void;
error: (error: string) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_15<__VLS_TypePropsToRuntimeProps_15<MapSearchControlProps>, {
position: string;
placeholder: string;
geocode: boolean;
flyTo: boolean;
flyToZoom: number;
}>>> & Readonly<{
onError?: ((error: string) => any) | undefined;
onSearch?: ((query: string) => any) | undefined;
onResult?: ((result: AisGeocodeResult) => any) | undefined;
}>, {
position: MapControlPosition_2;
placeholder: string;
geocode: boolean;
flyTo: boolean;
flyToZoom: number;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface MapSearchControlProps {
    position?: MapControlPosition_2;
    placeholder?: string;
    /** Whether to geocode the search query via AIS (default: true) */
    geocode?: boolean;
    /** Whether to fly to the geocoded location (default: true) */
    flyTo?: boolean;
    /** Zoom level when flying to location (default: 18) */
    flyToZoom?: number;
}

/**
 * Options for opening a panorama view
 */
export declare interface OpenPanoramaOptions {
    /** Longitude coordinate */
    lng: number;
    /** Latitude coordinate */
    lat: number;
    /** Year to display (optional, will use most recent if not specified) */
    year?: number;
    /** Initial yaw (horizontal rotation) in degrees */
    yaw?: number;
    /** Initial pitch (vertical rotation) in degrees */
    pitch?: number;
    /** Initial horizontal field of view in degrees */
    hFov?: number;
    /** Specific recording ID to open */
    recordingId?: string;
}

/**
 * GeoJSON FeatureCollection for parcel geometry
 */
export declare interface ParcelFeatureCollection {
    type: "FeatureCollection";
    features: Array<{
        type: "Feature";
        geometry: PolygonGeometry_2;
        properties: {
            parcelid: string;
        };
    }>;
}

/**
 * Result from querying a parcel at a point
 */
export declare interface ParcelQueryResult {
    parcelId: string;
    address: string | null;
}

/**
 * Configuration for Pictometry authentication
 */
declare interface PictometryAuthConfig {
    /** OAuth2 credentials */
    credentials: PictometryCredentials;
    /** Token endpoint URL (default: https://apicenter.eagleview.com/oauth2/v1/token) */
    tokenEndpoint?: string;
    /** Optional proxy URL for token requests (for CORS issues) */
    proxy?: string;
}

export declare const PictometryButton: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_19<__VLS_TypePropsToRuntimeProps_19<PictometryButtonProps>, {
position: string;
iconSize: number;
title: string;
active: boolean;
disabled: boolean;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
toggle: (payload: PictometryButtonTogglePayload) => void;
error: (error: Error) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_19<__VLS_TypePropsToRuntimeProps_19<PictometryButtonProps>, {
position: string;
iconSize: number;
title: string;
active: boolean;
disabled: boolean;
}>>> & Readonly<{
onError?: ((error: Error) => any) | undefined;
onToggle?: ((payload: PictometryButtonTogglePayload) => any) | undefined;
}>, {
position: MapControlPosition_3;
title: string;
iconSize: number;
active: boolean;
disabled: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Props for PictometryButton component
 */
export declare interface PictometryButtonProps {
    /** Button position on the map */
    position?: MapControlPosition_3;
    /** Custom icon class (FontAwesome) */
    icon?: string;
    /** Custom image URL (overrides icon) */
    image?: string;
    /** Button title/tooltip */
    title?: string;
    /** Whether Pictometry is currently active */
    active?: boolean;
    /** Icon size in pixels */
    iconSize?: number;
    /** Whether the button is disabled */
    disabled?: boolean;
}

/**
 * Updated emits interface for PictometryButton
 */
declare interface PictometryButtonTogglePayload {
    active: boolean;
    location: {
        lat: number;
        lng: number;
    };
}

/**
 * Full configuration for initializing the Pictometry viewer
 */
export declare interface PictometryConfig {
    /** OAuth2 access token (required) */
    authToken: string;
    /** Initial view settings */
    view?: PictometryView;
    /** Viewer preferences */
    preferences?: PictometryPreferences;
    /** Enable measurement panel (default: false) */
    measurementPanelEnabled?: boolean;
    /** Enable search bar (default: false) */
    searchBarEnabled?: boolean;
    /** Enable dual pane button (default: false) */
    enableDualPaneButton?: boolean;
}

/**
 * Pictometry/Eagleview TypeScript Type Definitions
 *
 * Types for integrating Eagleview's Embedded Explorer SDK for oblique aerial imagery.
 * The SDK is loaded from CDN and creates window.ev.EmbeddedExplorer.
 *
 * @module pictometry/types
 */
/**
 * OAuth2 client credentials for Eagleview API authentication
 */
export declare interface PictometryCredentials {
    /** OAuth2 client ID from Eagleview */
    clientId: string;
    /** OAuth2 client secret from Eagleview */
    clientSecret: string;
}

/**
 * Pictometry error object
 */
export declare interface PictometryError {
    /** Error message */
    message: string;
    /** Error type identifier */
    type: "auth" | "sdk_load" | "init" | "view" | "network" | "unknown";
    /** Additional error details */
    details?: unknown;
}

/**
 * Image display preferences
 */
declare interface PictometryImageDisplayPreferences {
    /** Main pane display mode: "oblique" | "ortho" | "street" */
    mainPane: "oblique" | "ortho" | "street";
}

/**
 * Longitude/Latitude coordinate pair
 */
declare interface PictometryLonLat {
    /** Longitude in decimal degrees */
    lon: number;
    /** Latitude in decimal degrees */
    lat: number;
}

export declare const PictometryPanel: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_20<__VLS_TypePropsToRuntimeProps_20<PictometryPanelProps_2>, {
autoOpen: boolean;
popOutEnabled: boolean;
showParcels: boolean;
showLabels: boolean;
}>>, {
initializeViewer: typeof initializeViewer_2;
updateLocation: (lng: number, lat: number) => void;
isInitialized: ComputedRef<boolean>;
isLoading: ComputedRef<boolean>;
error: ComputedRef<PictometryError | null>;
}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
ready: () => void;
"view-change": (view: PictometryView) => void;
error: (error: {
message: string;
type: string;
}) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_20<__VLS_TypePropsToRuntimeProps_20<PictometryPanelProps_2>, {
autoOpen: boolean;
popOutEnabled: boolean;
showParcels: boolean;
showLabels: boolean;
}>>> & Readonly<{
onError?: ((error: {
message: string;
type: string;
}) => any) | undefined;
onReady?: (() => any) | undefined;
"onView-change"?: ((view: PictometryView) => any) | undefined;
}>, {
autoOpen: boolean;
popOutEnabled: boolean;
showParcels: boolean;
showLabels: boolean;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

/**
 * Props for PictometryPanel component
 */
export declare interface PictometryPanelProps {
    /** Optional year filter (not used by Pictometry but for API consistency) */
    year?: number;
    /** Whether to auto-open viewer on mount */
    autoOpen?: boolean;
    /** Enable pop-out button */
    popOutEnabled?: boolean;
    /** Show layer controls (parcels, labels) */
    showLayerControls?: boolean;
}

/**
 * Props for PictometryPanel component
 */
declare interface PictometryPanelProps_2 {
    /** Whether to automatically open viewer on mount */
    autoOpen?: boolean;
    /** Whether to show pop-out button */
    popOutEnabled?: boolean;
    /** Show parcels layer by default */
    showParcels?: boolean;
    /** Show labels layer by default */
    showLabels?: boolean;
}

/**
 * Viewer preferences
 */
declare interface PictometryPreferences {
    /** Image display settings */
    imageDisplay?: PictometryImageDisplayPreferences;
}

/**
 * View configuration for the Pictometry viewer
 */
export declare interface PictometryView {
    /** Center coordinate of the view */
    lonLat: PictometryLonLat;
    /** Zoom level (default: 17) */
    zoom?: number;
    /** Pitch/tilt angle in degrees (default: 0 for oblique) */
    pitch?: number;
    /** Rotation/heading angle in degrees (default: 0) */
    rotation?: number;
}

declare interface PointGeometry {
    type: "Point";
    coordinates: number[];
}

declare interface PolygonGeometry {
    type: "Polygon";
    coordinates: number[][][];
}

/**
 * GeoJSON Polygon geometry
 */
declare interface PolygonGeometry_2 {
    type: "Polygon";
    coordinates: number[][][];
}

/**
 * Query the PWD parcel layer at a given point.
 * Returns parcel ID and address if found, or null if no parcel at that location.
 */
export declare function queryParcelAtPoint(lng: number, lat: number): Promise<ParcelQueryResult | null>;

export declare const RasterLayer: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_7<__VLS_TypePropsToRuntimeProps_7<RasterLayerProps>, {
paint: () => {};
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_7<__VLS_TypePropsToRuntimeProps_7<RasterLayerProps>, {
paint: () => {};
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
}>>> & Readonly<{}>, {
minzoom: number;
maxzoom: number;
beforeId: string;
paint: {
"raster-opacity"?: PropertyValueSpecification<number>;
"raster-opacity-transition"?: TransitionSpecification;
"raster-hue-rotate"?: PropertyValueSpecification<number>;
"raster-hue-rotate-transition"?: TransitionSpecification;
"raster-brightness-min"?: PropertyValueSpecification<number>;
"raster-brightness-min-transition"?: TransitionSpecification;
"raster-brightness-max"?: PropertyValueSpecification<number>;
"raster-brightness-max-transition"?: TransitionSpecification;
"raster-saturation"?: PropertyValueSpecification<number>;
"raster-saturation-transition"?: TransitionSpecification;
"raster-contrast"?: PropertyValueSpecification<number>;
"raster-contrast-transition"?: TransitionSpecification;
"raster-resampling"?: PropertyValueSpecification<"linear" | "nearest">;
"raster-fade-duration"?: PropertyValueSpecification<number>;
};
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface RasterLayerProps extends BaseProps {
    /** Unique layer ID */
    id: string;
    /** Raster source - either inline definition or reference to existing source ID */
    source: string | RasterSourceSpecification;
    /** Paint properties for raster styling (opacity, contrast, etc.) */
    paint?: RasterLayerSpecification["paint"];
    /** Minimum zoom level for layer visibility */
    minzoom?: number;
    /** Maximum zoom level for layer visibility */
    maxzoom?: number;
    /** ID of layer to insert this layer before */
    beforeId?: string;
}

/**
 * Configuration for the Recordings Client (WFS service)
 */
export declare interface RecordingsClientConfig {
    /** Base URL for the WFS service */
    baseUrl: string;
    /** Spatial Reference ID (e.g., 4326 for WGS84) */
    srid: number;
    /** Optional proxy URL for CORS */
    proxy?: string;
    /** Credentials for WFS authentication */
    credentials?: {
        username: string;
        password: string;
    };
    /** Maximum number of features to return */
    maxFeatures?: number;
    /** Type name for the WFS layer */
    typeName?: string;
}

/**
 * Result from recordings query
 */
export declare interface RecordingsQueryResult {
    /** Array of recordings found */
    recordings: CyclomediaRecording[];
    /** Total count of recordings */
    totalCount: number;
    /** Whether the query is still loading */
    isLoading: boolean;
    /** Error if the query failed */
    error: CyclomediaError | null;
}

declare type ShapeGeometry = PolygonGeometry | LineStringGeometry | PointGeometry;

export declare const SymbolLayer: DefineComponent<ExtractPropTypes<__VLS_WithDefaults_6<__VLS_TypePropsToRuntimeProps_6<SymbolLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
icon: undefined;
iconName: undefined;
}>>, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
click: (event: MapLayerMouseEvent) => void;
dblclick: (event: MapLayerMouseEvent) => void;
mouseenter: (event: MapLayerMouseEvent) => void;
mouseleave: (event: MapLayerMouseEvent) => void;
mousemove: (event: MapLayerMouseEvent) => void;
mousedown: (event: MapLayerMouseEvent) => void;
mouseup: (event: MapLayerMouseEvent) => void;
contextmenu: (event: MapLayerMouseEvent) => void;
}, string, PublicProps, Readonly<ExtractPropTypes<__VLS_WithDefaults_6<__VLS_TypePropsToRuntimeProps_6<SymbolLayerProps>, {
sourceLayer: undefined;
paint: () => {};
layout: () => {};
filter: undefined;
minzoom: undefined;
maxzoom: undefined;
beforeId: undefined;
icon: undefined;
iconName: undefined;
}>>> & Readonly<{
onClick?: ((event: MapLayerMouseEvent) => any) | undefined;
onDblclick?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousedown?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseup?: ((event: MapLayerMouseEvent) => any) | undefined;
onMousemove?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseenter?: ((event: MapLayerMouseEvent) => any) | undefined;
onMouseleave?: ((event: MapLayerMouseEvent) => any) | undefined;
onContextmenu?: ((event: MapLayerMouseEvent) => any) | undefined;
}>, {
icon: string;
sourceLayer: string;
filter: FilterSpecification;
minzoom: number;
maxzoom: number;
beforeId: string;
paint: {
"icon-opacity"?: DataDrivenPropertyValueSpecification<number>;
"icon-opacity-transition"?: TransitionSpecification;
"icon-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"icon-color-transition"?: TransitionSpecification;
"icon-halo-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"icon-halo-color-transition"?: TransitionSpecification;
"icon-halo-width"?: DataDrivenPropertyValueSpecification<number>;
"icon-halo-width-transition"?: TransitionSpecification;
"icon-halo-blur"?: DataDrivenPropertyValueSpecification<number>;
"icon-halo-blur-transition"?: TransitionSpecification;
"icon-translate"?: PropertyValueSpecification<[number, number]>;
"icon-translate-transition"?: TransitionSpecification;
"icon-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
"text-opacity"?: DataDrivenPropertyValueSpecification<number>;
"text-opacity-transition"?: TransitionSpecification;
"text-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"text-color-transition"?: TransitionSpecification;
"text-halo-color"?: DataDrivenPropertyValueSpecification<ColorSpecification>;
"text-halo-color-transition"?: TransitionSpecification;
"text-halo-width"?: DataDrivenPropertyValueSpecification<number>;
"text-halo-width-transition"?: TransitionSpecification;
"text-halo-blur"?: DataDrivenPropertyValueSpecification<number>;
"text-halo-blur-transition"?: TransitionSpecification;
"text-translate"?: PropertyValueSpecification<[number, number]>;
"text-translate-transition"?: TransitionSpecification;
"text-translate-anchor"?: PropertyValueSpecification<"map" | "viewport">;
};
layout: {
"symbol-placement"?: PropertyValueSpecification<"point" | "line" | "line-center">;
"symbol-spacing"?: PropertyValueSpecification<number>;
"symbol-avoid-edges"?: PropertyValueSpecification<boolean>;
"symbol-sort-key"?: DataDrivenPropertyValueSpecification<number>;
"symbol-z-order"?: PropertyValueSpecification<"auto" | "viewport-y" | "source">;
"icon-allow-overlap"?: PropertyValueSpecification<boolean>;
"icon-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">;
"icon-ignore-placement"?: PropertyValueSpecification<boolean>;
"icon-optional"?: PropertyValueSpecification<boolean>;
"icon-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
"icon-size"?: DataDrivenPropertyValueSpecification<number>;
"icon-text-fit"?: PropertyValueSpecification<"none" | "width" | "height" | "both">;
"icon-text-fit-padding"?: PropertyValueSpecification<[number, number, number, number]>;
"icon-image"?: DataDrivenPropertyValueSpecification<ResolvedImageSpecification>;
"icon-rotate"?: DataDrivenPropertyValueSpecification<number>;
"icon-padding"?: DataDrivenPropertyValueSpecification<PaddingSpecification>;
"icon-keep-upright"?: PropertyValueSpecification<boolean>;
"icon-offset"?: DataDrivenPropertyValueSpecification<[number, number]>;
"icon-anchor"?: DataDrivenPropertyValueSpecification<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">;
"icon-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
"text-pitch-alignment"?: PropertyValueSpecification<"map" | "viewport" | "auto">;
"text-rotation-alignment"?: PropertyValueSpecification<"map" | "viewport" | "viewport-glyph" | "auto">;
"text-field"?: DataDrivenPropertyValueSpecification<FormattedSpecification>;
"text-font"?: DataDrivenPropertyValueSpecification<Array<string>>;
"text-size"?: DataDrivenPropertyValueSpecification<number>;
"text-max-width"?: DataDrivenPropertyValueSpecification<number>;
"text-line-height"?: PropertyValueSpecification<number>;
"text-letter-spacing"?: DataDrivenPropertyValueSpecification<number>;
"text-justify"?: DataDrivenPropertyValueSpecification<"auto" | "left" | "center" | "right">;
"text-radial-offset"?: DataDrivenPropertyValueSpecification<number>;
"text-variable-anchor"?: PropertyValueSpecification<Array<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">>;
"text-variable-anchor-offset"?: DataDrivenPropertyValueSpecification<VariableAnchorOffsetCollectionSpecification>;
"text-anchor"?: DataDrivenPropertyValueSpecification<"center" | "left" | "right" | "top" | "bottom" | "top-left" | "top-right" | "bottom-left" | "bottom-right">;
"text-max-angle"?: PropertyValueSpecification<number>;
"text-writing-mode"?: PropertyValueSpecification<Array<"horizontal" | "vertical">>;
"text-rotate"?: DataDrivenPropertyValueSpecification<number>;
"text-padding"?: PropertyValueSpecification<number>;
"text-keep-upright"?: PropertyValueSpecification<boolean>;
"text-transform"?: DataDrivenPropertyValueSpecification<"none" | "uppercase" | "lowercase">;
"text-offset"?: DataDrivenPropertyValueSpecification<[number, number]>;
"text-allow-overlap"?: PropertyValueSpecification<boolean>;
"text-overlap"?: PropertyValueSpecification<"never" | "always" | "cooperative">;
"text-ignore-placement"?: PropertyValueSpecification<boolean>;
"text-optional"?: PropertyValueSpecification<boolean>;
visibility?: VisibilitySpecification;
};
iconName: string;
}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;

declare interface SymbolLayerProps extends BaseLayerProps {
    /** Paint properties for symbol styling */
    paint?: SymbolLayerSpecification["paint"];
    /** Layout properties (includes text and icon settings) */
    layout?: SymbolLayerSpecification["layout"];
    /** URL or path to icon image — when provided, the image is loaded and registered automatically */
    icon?: string;
    /** Name to register the icon image under (required when icon is provided) */
    iconName?: string;
}

declare function toggleDropdown(): void;

/**
 * Composable for adding MapLibre controls to the map.
 *
 * This composable handles positioning controls in MapLibre's corner containers
 * (top-left, top-right, etc.) and automatic cleanup on unmount.
 *
 * ## What is IControl?
 *
 * IControl is MapLibre's interface for map controls. It's not a class you extend -
 * it's a TypeScript interface that uses "duck typing": any object with the right
 * methods qualifies. The required methods are:
 *
 *   - onAdd(map): Called when control is added. Must return an HTMLElement.
 *   - onRemove(): Called when control is removed. Handle any cleanup here.
 *
 * So this plain object is a valid IControl:
 *
 *   { onAdd() { return myDiv; }, onRemove() {} }
 *
 * ## Usage
 *
 * For Vue template-based controls (MapButton, MapSearchControl, BasemapDropdown),
 * pass a ref to the container element. The composable creates the IControl internally,
 * returning your Vue template's DOM element from onAdd():
 *
 *   const containerRef = ref<HTMLElement | null>(null);
 *   useMapControl(props, containerRef);
 *
 * For MapLibre's built-in controls (like NavigationControl), pass a function that
 * returns the control. These already implement IControl internally:
 *
 *   useMapControl(props, () => new maplibregl.NavigationControl());
 */
export declare function useMapControl(props: {
    position?: MapControlPosition_2;
}, controlOrContainer: Ref<HTMLElement | null> | (() => IControl)): void;

/**
 * Validate credentials format (doesn't verify with server)
 *
 * @param credentials - Credentials to validate
 * @returns True if credentials have valid format
 */
export declare function validateCredentials(credentials: PictometryCredentials): boolean;

/**
 * Event payload for view change events
 */
export declare interface ViewChangeEvent {
    /** Type of event */
    type: CyclomediaEvents;
    /** Current camera position */
    cameraPosition: CameraPosition;
    /** Current recording ID */
    recordingId?: string;
    /** Year of the imagery */
    year?: number;
}

export { }


declare global {
    interface Window {
        deleteActivePolygon?: () => void;
        cancelDrawing?: () => void;
        finishDrawing?: () => void;
    }
}


/**
 * Augment window type with Eagleview namespace
 */
declare global {
    interface Window {
        ev?: EagleviewNamespace;
    }
}

