@dereekb/dbx-web 12.6.21 → 13.0.0

package/types/dereekb-dbx-web-mapbox.d.ts

@@ -0,0 +1,752 @@
+import * as rxjs from 'rxjs';
+import { OperatorFunction, Observable, Subscription, Subject } from 'rxjs';
+import * as i0 from '@angular/core';
+import { OnDestroy, Provider, OnInit, Signal, ElementRef, EnvironmentProviders } from '@angular/core';
+import * as _dereekb_util from '@dereekb/util';
+import { ZoomLevel, ExtendLatLngBoundInput, LatLngBoundInput, LatLngPointInput, ZoomLevelRange, LatLngPoint, LatLngBound, Vector, Maybe, LatLngBoundCheckFunction, LatLngPrecision, RoundNumberToStepFunctionInput, IsWithinLatLngBoundFunction, OverlapsLatLngBoundFunction, Milliseconds, UniqueModel, LatLngInputRef, CssClassesArray, FactoryWithRequiredInput, Pixels, CssStyleObject } from '@dereekb/util';
+import { ComponentStore } from '@ngrx/component-store';
+import * as i10 from 'ngx-mapbox-gl';
+import { MapService, MapComponent, provideMapboxGL } from 'ngx-mapbox-gl';
+import * as MapboxGl from 'mapbox-gl';
+import { Map as Map$1, MapEventType, MapOptions } from 'mapbox-gl';
+import * as _dereekb_dbx_core from '@dereekb/dbx-core';
+import { DbxInjectionComponentConfig, DbxInjectionComponentConfigWithoutInjector, ClickableAnchor } from '@dereekb/dbx-core';
+import { ObservableOrValue, ObservableOrValueGetter, SubscriptionObject } from '@dereekb/rxjs';
+import * as _dereekb_dbx_web_mapbox from '@dereekb/dbx-web/mapbox';
+import { DbxThemeColor, ResizedEvent } from '@dereekb/dbx-web';
+import { MatDrawerContainer } from '@angular/material/sidenav';
+import { MatMenuTrigger } from '@angular/material/menu';
+
+/**
+ * List of styles that are defined here:
+ *
+ * https://docs.mapbox.com/api/maps/styles/
+ */
+type KnownMapboxStyle = 'mapbox://styles/mapbox/standard' | 'mapbox://styles/mapbox/streets-v12' | 'mapbox://styles/mapbox/outdoors-v12' | 'mapbox://styles/mapbox/light-v11' | 'mapbox://styles/mapbox/dark-v11' | 'mapbox://styles/mapbox/satellite-v9' | 'mapbox://styles/mapbox/satellite-streets-v12' | 'mapbox://styles/mapbox/navigation-day-v1' | 'mapbox://styles/mapbox/navigation-night-v1';
+declare const KNOWN_MAPBOX_STYLES: KnownMapboxStyle[];
+type MapboxEventData = object;
+type MapboxZoomLevel = ZoomLevel;
+type MapboxZoomLevelRange = ZoomLevelRange;
+declare const MAPBOX_MIN_ZOOM_LEVEL: MapboxZoomLevel;
+declare const MAPBOX_MAX_ZOOM_LEVEL: MapboxZoomLevel;
+declare function mapboxZoomLevel(input: number): MapboxZoomLevel;
+type MapboxPitch = number;
+type MapboxBearing = number;
+/**
+ * Size of the tiles. Vector-based tiles used by the web are generally 512x512, and legacy ones are 256x256.
+ *
+ * https://blog.mapbox.com/512-map-tiles-cb5bfd6e72ba
+ */
+type MapboxTileSize = 512 | 256;
+type DbxMapboxClickEvent = MapboxGl.MapMouseEvent & MapboxEventData;
+/**
+ * Options for MapboxGl.Map.fitBounds()
+ */
+type MapboxFitBoundsOptions = Parameters<MapboxGl.Map['fitBounds']>[1];
+/**
+ * Options for MapboxGl.Map.easeTo()
+ */
+type MapboxEaseToOptions = Parameters<MapboxGl.Map['easeTo']>[0];
+/**
+ * Options for MapboxGl.Map.flyTo()
+ */
+type MapboxFlyToOptions = Parameters<MapboxGl.Map['flyTo']>[0];
+/**
+ * Options for MapboxGl.Map.setStyle()
+ */
+type MapboxSetStyleOptions = Parameters<MapboxGl.Map['setStyle']>[1];
+interface MapboxStyleConfig {
+    style: MapboxGl.StyleSpecification | string;
+    options?: MapboxSetStyleOptions;
+}
+interface MapboxFitPositions {
+    positions: ExtendLatLngBoundInput;
+    options?: MapboxFitBoundsOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxFitBounds {
+    bounds: LatLngBoundInput;
+    options?: MapboxFitBoundsOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxJumpToPositionOptions extends Omit<MapboxGl.CameraOptions, 'center'> {
+    center: LatLngPointInput;
+}
+interface MapboxJumpTo {
+    center?: LatLngPointInput;
+    to?: MapboxJumpToPositionOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxEaseToPositionOptions extends Omit<MapboxEaseToOptions, 'center'>, MapboxJumpToPositionOptions {
+}
+interface MapboxEaseTo {
+    center?: LatLngPointInput;
+    to?: MapboxEaseToPositionOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxFlyToPositionOptions extends Omit<MapboxFlyToOptions, 'center'>, MapboxJumpToPositionOptions {
+}
+interface MapboxFlyTo {
+    center?: LatLngPointInput;
+    to?: MapboxFlyToPositionOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxRotateTo {
+    bearing: MapboxBearing;
+    options?: mapboxgl.AnimationOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxResetNorth {
+    options?: mapboxgl.AnimationOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxResetNorthPitch {
+    options?: mapboxgl.AnimationOptions;
+    eventData?: MapboxEventData;
+}
+interface MapboxSnapToNorth {
+    options?: mapboxgl.AnimationOptions;
+    eventData?: MapboxEventData;
+}
+
+interface MapboxViewportBoundFunctionConfig {
+    readonly mapCanvasSize: Vector;
+    /**
+     * Mapbox tilesize being used. Defaults to 512x512.
+     */
+    readonly tileSize?: MapboxTileSize;
+}
+/**
+ * Input for MapboxViewportBoundFunction.
+ */
+interface MapboxViewportBoundFunctionInput {
+    /**
+     * Center of the viewport
+     */
+    readonly center: LatLngPoint;
+    /**
+     * Zoom level
+     */
+    readonly zoom: MapboxZoomLevel;
+}
+/**
+ * Used to calculate the bounds of a view/object given the input MapboxViewportBoundFunctionInput.
+ */
+type MapboxViewportBoundFunction = (input: MapboxViewportBoundFunctionInput) => LatLngBound;
+declare function mapboxViewportBoundFunction(config: MapboxViewportBoundFunctionConfig): MapboxViewportBoundFunction;
+
+type FilterMapboxBoundReadItemValueFunction<T> = (value: T) => MapboxViewportBoundFunctionItemValue;
+interface FilterMapboxBoundConfig<T> {
+    readonly boundFunctionObs: ObservableOrValue<MapboxViewportBoundFunction>;
+    readonly boundDecisionObs: ObservableOrValue<LatLngBoundCheckFunction>;
+    /**
+     * Reads the value from the input item.
+     */
+    readonly readValue: FilterMapboxBoundReadItemValueFunction<T>;
+    /**
+     * Minimum precision to retain. Defaults to LAT_LONG_10M_PRECISION
+     */
+    readonly precision?: LatLngPrecision;
+    /**
+     * Amount of zoom rounding to use. By default rounds to 0.5 steps using "floor" in order to "round up" since zoom values are inversely proportional to bounds area.
+     */
+    readonly zoomRounding?: RoundNumberToStepFunctionInput;
+    /**
+     * Default zoom level for item values that do not have an explicit zoom, or a zoom of 0.
+     *
+     * Defaults to 17, which can produce a viewport/bounds about the size of a park.
+     */
+    readonly defaultZoom?: MapboxZoomLevel;
+}
+interface MapboxViewportBoundFunctionItemValue {
+    readonly center: LatLngPointInput;
+    readonly zoom?: Maybe<MapboxZoomLevel>;
+}
+interface MapboxViewportBoundFunctionItem<T> {
+    readonly value: T;
+    readonly bound: LatLngBound;
+}
+/**
+ * Filters the input objects based on their center and zoom values.
+ *
+ * This function caches the bounds computations for each of the input values.
+ *
+ * @param config
+ * @returns
+ */
+declare function filterByMapboxViewportBound<T>(config: FilterMapboxBoundConfig<T>): OperatorFunction<T[], T[]>;
+
+type MapboxMapLifecycleState = 'init' | 'load' | 'render' | 'idle';
+type MapboxMapMoveState = 'init' | 'idle' | 'moving';
+type MapboxMapZoomState = 'init' | 'idle' | 'zooming';
+type MapboxMapRotateState = 'init' | 'idle' | 'rotating';
+interface StringMapboxListenerPair {
+    type: string;
+    listener: (ev: MapboxEventData) => void;
+}
+interface TypedMapboxListenerPair<T extends keyof MapEventType> {
+    type: T;
+    listener: (ev: MapEventType[T] & MapboxEventData) => void;
+}
+interface DbxMapboxMarginCalculationSizing {
+    leftMargin: number;
+    rightMargin: number;
+    fullWidth: number;
+}
+type DbxMapboxStoreBoundRefreshType = 'always' | 'when_not_rendering' | 'only_after_render_finishes';
+interface DbxMapboxStoreBoundRefreshSettings {
+    /**
+     * Max bound refresh interval.
+     */
+    throttle: number;
+    /**
+     * Whether or not to wait to update the bound until after it has finished rendering.
+     */
+    refreshType: DbxMapboxStoreBoundRefreshType;
+}
+interface DbxMapboxStoreState {
+    /**
+     * Current MapService being utilized.
+     */
+    readonly mapService?: Maybe<MapService>;
+    readonly lifecycleState: MapboxMapLifecycleState;
+    readonly moveState: MapboxMapMoveState;
+    readonly zoomState: MapboxMapZoomState;
+    readonly rotateState: MapboxMapRotateState;
+    /**
+     * Visual container size of the map.
+     */
+    readonly mapCanvasSize?: Maybe<Vector>;
+    /**
+     * Latest click event
+     */
+    readonly clickEvent?: Maybe<DbxMapboxClickEvent>;
+    /**
+     * Latest double-click event
+     */
+    readonly doubleClickEvent?: Maybe<DbxMapboxClickEvent>;
+    /**
+     * Latest contextmenu event.
+     */
+    readonly rightClickEvent?: Maybe<DbxMapboxClickEvent>;
+    /**
+     * Whether or not to retain content between resets.
+     *
+     * True by default.
+     */
+    readonly retainContent: boolean;
+    /**
+     * Custom drawer content configuration.
+     */
+    readonly drawerContent?: Maybe<DbxInjectionComponentConfig<unknown>>;
+    /**
+     * Latest error
+     */
+    readonly error?: Maybe<Error>;
+    /**
+     * Map margin/offset
+     */
+    readonly margin?: Maybe<DbxMapboxMarginCalculationSizing>;
+    /**
+     * Minimum vector size to use for the viewportBoundFunction$. If not defined there is no minimum.
+     */
+    readonly minimumVirtualViewportSize?: Maybe<Partial<Vector>>;
+    /**
+     * Bound refresh settings
+     */
+    readonly boundRefreshSettings: DbxMapboxStoreBoundRefreshSettings;
+    /**
+     * Whether or not to use the virtual bound (vs raw bound) for all bound-related observables.
+     *
+     * Defaults to true.
+     */
+    readonly useVirtualBound: boolean;
+}
+/**
+ * Store used for retrieving information.
+ */
+declare class DbxMapboxMapStore extends ComponentStore<DbxMapboxStoreState> {
+    private readonly dbxMapboxService;
+    private safeLatLngPoint;
+    private latLngPoint;
+    private latLngBound;
+    constructor();
+    readonly setMapService: (observableOrValue: Maybe<MapService> | Observable<Maybe<MapService>>) => Subscription;
+    readonly setStyle: (observableOrValue: string | MapboxStyleConfig | Observable<string | MapboxStyleConfig>) => Subscription;
+    readonly setCenter: (observableOrValue: LatLngPointInput | Observable<LatLngPointInput>) => Subscription;
+    readonly setZoom: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setZoomRange: (observableOrValue: Partial<_dereekb_util.ZoomLevelRange> | Observable<Partial<_dereekb_util.ZoomLevelRange>>) => Subscription;
+    readonly setMinZoom: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setMaxZoom: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setKeyboardDisabled: (observableOrValue: void | Maybe<boolean> | Observable<void | Maybe<boolean>>) => Subscription;
+    readonly setDragRotateDisabled: (observableOrValue: void | Maybe<boolean> | Observable<void | Maybe<boolean>>) => Subscription;
+    readonly setDragPanDisabled: (observableOrValue: void | Maybe<boolean> | Observable<void | Maybe<boolean>>) => Subscription;
+    readonly setZoomDisabled: (observableOrValue: void | Maybe<boolean> | Observable<void | Maybe<boolean>>) => Subscription;
+    readonly setPitch: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setMinPitch: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setMaxPitch: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly setBearing: (observableOrValue: number | Observable<number>) => Subscription;
+    readonly rotateTo: (observableOrValue: number | MapboxRotateTo | Observable<number | MapboxRotateTo>) => Subscription;
+    readonly resetNorth: (observableOrValue: void | Maybe<MapboxResetNorth> | Observable<void | Maybe<MapboxResetNorth>>) => Subscription;
+    readonly resetNorthPitch: (observableOrValue: void | Maybe<MapboxResetNorthPitch> | Observable<void | Maybe<MapboxResetNorthPitch>>) => Subscription;
+    readonly snapToNorth: (observableOrValue: void | Maybe<MapboxSnapToNorth> | Observable<void | Maybe<MapboxSnapToNorth>>) => Subscription;
+    readonly fitPositions: (observableOrValue: MapboxFitPositions | Observable<MapboxFitPositions>) => Subscription;
+    readonly fitBounds: (observableOrValue: MapboxFitBounds | Observable<MapboxFitBounds>) => Subscription;
+    readonly jumpTo: (observableOrValue: MapboxJumpTo | Observable<MapboxJumpTo>) => Subscription;
+    readonly easeTo: (observableOrValue: MapboxEaseTo | Observable<MapboxEaseTo>) => Subscription;
+    readonly flyTo: (observableOrValue: MapboxFlyTo | Observable<MapboxFlyTo>) => Subscription;
+    readonly resetPitchAndBearing: (observableOrValue?: void | Observable<void> | undefined) => Subscription;
+    get timerRefreshPeriod(): number;
+    movingTimer(period?: number): Observable<number>;
+    lifecycleRenderTimer(period?: number): Observable<number>;
+    atNextIdle(): Observable<boolean>;
+    calculateNextCenterWithOffset(inputOffset: LatLngPointInput): Observable<LatLngPoint>;
+    calculateNextCenterOffsetWithScreenMarginChange(sizing: DbxMapboxMarginCalculationSizing): Observable<LatLngPoint>;
+    filterByViewportBound<T>(input: FilterMapboxBoundReadItemValueFunction<T> | Omit<FilterMapboxBoundConfig<T>, 'boundFunctionObs' | 'boundDecisionObs'>): OperatorFunction<T[], T[]>;
+    readonly currentMapService$: Observable<Maybe<MapService>>;
+    readonly mapService$: Observable<MapService>;
+    readonly currentMapInstance$: Observable<Maybe<Map$1>>;
+    readonly mapInstance$: Observable<Map$1>;
+    readonly boundRefreshSettings$: Observable<DbxMapboxStoreBoundRefreshSettings>;
+    readonly moveState$: Observable<MapboxMapMoveState>;
+    readonly lifecycleState$: Observable<MapboxMapLifecycleState>;
+    readonly zoomState$: Observable<MapboxMapZoomState>;
+    readonly rotateState$: Observable<MapboxMapRotateState>;
+    readonly isInitialized$: Observable<boolean>;
+    readonly whenInitialized$: Observable<boolean>;
+    readonly isRendering$: Observable<boolean>;
+    readonly isMoving$: Observable<boolean>;
+    readonly isZooming$: Observable<boolean>;
+    readonly isRotating$: Observable<boolean>;
+    private readonly _movingTimer;
+    private readonly _renderingTimer;
+    readonly centerNow$: Observable<LatLngPoint>;
+    readonly center$: Observable<LatLngPoint>;
+    readonly minimumVirtualViewportSize$: Observable<Maybe<Partial<Vector>>>;
+    readonly currentMapCanvasSize$: Observable<Maybe<Vector>>;
+    /**
+     * The map canvas size with consideration to the virtual viewport size.
+     */
+    readonly mapCanvasSize$: Observable<Vector>;
+    minimumMapCanvasSize(minVector: Partial<Vector>): Observable<Vector>;
+    /**
+     * The map canvas size with consideration to the virtual viewport size.
+     */
+    readonly virtualMapCanvasSize$: Observable<Vector>;
+    readonly rawViewportBoundFunction$: Observable<MapboxViewportBoundFunction>;
+    /**
+     * Creates a MapboxViewportBoundFunction observable that returns the minimum viewport size.
+     *
+     * @param minVector
+     * @returns
+     */
+    viewportBoundFunctionWithMinimumSize(minVector: Partial<Vector>): Observable<MapboxViewportBoundFunction>;
+    readonly viewportBoundFunction$: Observable<MapboxViewportBoundFunction>;
+    readonly virtualBound$: Observable<LatLngBound>;
+    readonly margin$: Observable<Maybe<DbxMapboxMarginCalculationSizing>>;
+    readonly reverseMargin$: Observable<{
+        leftMargin: number;
+        rightMargin: number;
+        fullWidth: number;
+    } | null | undefined>;
+    readonly centerGivenMargin$: Observable<LatLngPoint>;
+    readonly rawBoundNow$: Observable<LatLngBound>;
+    readonly rawBound$: Observable<LatLngBound>;
+    readonly useVirtualBound$: Observable<boolean>;
+    readonly bound$: Observable<LatLngBound>;
+    readonly boundSizing$: Observable<LatLngPoint>;
+    readonly boundWrapsAroundWorld$: Observable<boolean>;
+    readonly isWithinBoundFunction$: Observable<IsWithinLatLngBoundFunction>;
+    readonly overlapsBoundFunction$: Observable<OverlapsLatLngBoundFunction>;
+    readonly zoomNow$: Observable<MapboxZoomLevel>;
+    readonly zoom$: Observable<MapboxZoomLevel>;
+    readonly pitchNow$: Observable<number>;
+    readonly pitch$: Observable<number>;
+    readonly bearingNow$: Observable<number>;
+    readonly bearing$: Observable<number>;
+    readonly drawerContent$: Observable<Maybe<DbxInjectionComponentConfig<unknown>>>;
+    readonly hasDrawerContent$: Observable<boolean>;
+    readonly clickEvent$: Observable<Maybe<DbxMapboxClickEvent>>;
+    readonly doubleClickEvent$: Observable<Maybe<DbxMapboxClickEvent>>;
+    readonly rightClickEvent$: Observable<Maybe<DbxMapboxClickEvent>>;
+    readonly setMargin: (() => void) | ((observableOrValue: Maybe<DbxMapboxMarginCalculationSizing> | Observable<Maybe<DbxMapboxMarginCalculationSizing>>) => Subscription);
+    readonly setMinimumVirtualViewportSize: (() => void) | ((observableOrValue: Maybe<Partial<Vector>> | Observable<Maybe<Partial<Vector>>>) => Subscription);
+    readonly setUseVirtualBound: (observableOrValue: boolean | Observable<boolean>) => Subscription;
+    readonly setBoundRefreshSettings: (observableOrValue: Partial<DbxMapboxStoreBoundRefreshSettings> | Observable<Partial<DbxMapboxStoreBoundRefreshSettings>>) => Subscription;
+    private readonly _setMapService;
+    private readonly _setLifecycleState;
+    private readonly _setMoveState;
+    private readonly _setZoomState;
+    private readonly _setRotateState;
+    private readonly _setMapCanvasSize;
+    private readonly _setClickEvent;
+    private readonly _setDoubleClickEvent;
+    private readonly _setRightClickEvent;
+    private readonly _setError;
+    readonly clearDrawerContent: () => void;
+    readonly setDrawerContent: (() => void) | ((observableOrValue: Maybe<DbxInjectionComponentConfig<unknown>> | Observable<Maybe<DbxInjectionComponentConfig<unknown>>>) => Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMapStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxMapboxMapStore>;
+}
+
+/**
+ * Provided in the parent component that allows children to emit events related to their lifecycles.
+ */
+declare class DbxMapboxChangeService implements OnDestroy {
+    readonly dbxMapboxMapStore: DbxMapboxMapStore;
+    private readonly _markerDestroyed;
+    private readonly _applyChanges;
+    readonly markerDestroyed$: Subject<void>;
+    readonly applyChanges$: rxjs.Observable<void>;
+    private readonly _applyChangesSub;
+    applyChanges(): void;
+    emitMarkerDestroyed(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxChangeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxMapboxChangeService>;
+}
+
+type DbxMapboxInjectionKey = string;
+interface DbxMapboxInjectionConfig {
+    /**
+     * Unique key that identifies this config specifically.
+     *
+     * Keys should all be unique. The system does not expect duplicate keys. Modifications to injectionConfig should occur through the observable value.
+     */
+    readonly key: DbxMapboxInjectionKey;
+    /**
+     * Arbitrary injection type. Is used for filtering on configurations.
+     */
+    readonly type?: string;
+    /**
+     * Injection configuration. The injector is disallowed, as the parent injector must include the mapbox component.
+     */
+    readonly injectionConfig: ObservableOrValueGetter<DbxInjectionComponentConfigWithoutInjector>;
+}
+interface DbxMapboxMapInjectionStoreState {
+    /**
+     * Current map of injection keys and configurations.
+     */
+    readonly map: Map<DbxMapboxInjectionKey, DbxMapboxInjectionConfig>;
+}
+/**
+ * Store used for storing injectable content into the map.
+ */
+declare class DbxMapboxInjectionStore extends ComponentStore<DbxMapboxMapInjectionStoreState> {
+    constructor();
+    readonly map$: Observable<Map<DbxMapboxInjectionKey, DbxMapboxInjectionConfig>>;
+    readonly allInjectionConfigs$: Observable<DbxMapboxInjectionConfig[]>;
+    readonly addInjectionConfig: (observableOrValue: DbxMapboxInjectionConfig | Observable<DbxMapboxInjectionConfig>) => rxjs.Subscription;
+    readonly removeInjectionConfigWithKey: (observableOrValue: string | Observable<string>) => rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxInjectionStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxMapboxInjectionStore>;
+}
+declare function updateDbxMapboxMapInjectionStoreStateWithInjectionConfig(state: DbxMapboxMapInjectionStoreState, config: DbxMapboxInjectionConfig): {
+    map: Map<string, DbxMapboxInjectionConfig>;
+};
+declare function updateDbxMapboxMapInjectionStoreStateWithRemovedKey(state: DbxMapboxMapInjectionStoreState, key: DbxMapboxInjectionKey): DbxMapboxMapInjectionStoreState;
+
+/**
+ * Injects the components configured in the DbxMapboxInjectionStore into the view.
+ */
+declare class DbxMapboxInjectionComponent {
+    readonly dbxMapboxMapKeyInjectionStore: DbxMapboxInjectionStore;
+    readonly entriesSignal: i0.Signal<_dereekb_dbx_web_mapbox.DbxMapboxInjectionConfig[] | undefined>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxInjectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxMapboxInjectionComponent, "dbx-mapbox-injection", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Token used by provideMapboxInjectionStoreIfDoesNotExist() to prevent injecting a parent DbxMapboxInjectionStore into the child view.
+ */
+declare class DbxMapboxInjectionStoreProviderBlock {
+    readonly dbxMapboxInjectionStore: DbxMapboxInjectionStore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxInjectionStoreProviderBlock, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxMapboxInjectionStoreProviderBlock>;
+}
+declare class DbxMapboxInjectionStoreInjectionBlockDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxInjectionStoreInjectionBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxMapboxInjectionStoreInjectionBlockDirective, "[dbxMapboxInjectionStoreParentBlocker]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Creates a Provider that initializes a new DbxMapboxInjectionStore if a parent does not exist.
+ *
+ * If a DbxMapboxInjectionStoreInjectionBlock is available in the context, and references the same dbxMapboxInjectionStore that is attempting to be injected, a new DbxMapboxInjectionStore is created.
+ *
+ * @returns
+ */
+declare function provideMapboxInjectionStoreIfParentIsUnavailable(): Provider;
+
+type DbxMapboxLayoutSide = 'left' | 'right';
+type DbxMapboxLayoutMode = 'side' | 'push';
+/**
+ * Responsive component meant to split a left and right column.
+ *
+ * The left column is smaller than the right column, which contains the primary content.
+ *
+ * Requires a TwoColumnsContextStore to be provided.
+ */
+declare class DbxMapboxLayoutComponent implements OnInit, OnDestroy {
+    readonly dbxMapboxMapStore: DbxMapboxMapStore;
+    private readonly _viewResized;
+    private readonly _refreshContentMargins;
+    readonly drawerOpenedChange: i0.OutputEmitterRef<boolean>;
+    readonly drawerContainer: Signal<MatDrawerContainer>;
+    readonly drawerContainerElement: Signal<ElementRef<HTMLElement>>;
+    readonly drawerContent: Signal<ElementRef<HTMLElement>>;
+    readonly side: i0.InputSignalWithTransform<DbxMapboxLayoutSide, Maybe<DbxMapboxLayoutSide>>;
+    readonly mode: i0.InputSignalWithTransform<DbxMapboxLayoutMode, Maybe<DbxMapboxLayoutMode>>;
+    /**
+     * Forces the drawer to assume the drawer has content if true, or assume it has no content if false.
+     */
+    readonly forceHasDrawerContent: i0.InputSignal<Maybe<boolean>>;
+    readonly drawerButtonColor: i0.InputSignalWithTransform<DbxThemeColor, Maybe<DbxThemeColor>>;
+    readonly openDrawer: i0.InputSignal<Maybe<boolean>>;
+    readonly isDrawerOpenSignal: i0.WritableSignal<Maybe<boolean>>;
+    protected readonly _openDrawerEffect: i0.EffectRef;
+    readonly storeHasDrawerContent: Signal<boolean | undefined>;
+    readonly drawerHasContentSignal: Signal<boolean | undefined>;
+    readonly refreshContentMargins$: Subject<void>;
+    readonly isOpenAndHasContentSignal: Signal<Maybe<boolean>>;
+    readonly viewResized$: Observable<ResizedEvent>;
+    readonly side$: Observable<DbxMapboxLayoutSide>;
+    readonly mode$: Observable<DbxMapboxLayoutMode>;
+    readonly drawerHasContent$: Observable<boolean | undefined>;
+    readonly isOpenAndHasContent$: Observable<Maybe<boolean>>;
+    readonly positionSignal: Signal<'start' | 'end'>;
+    readonly drawerClassesSignal: Signal<string>;
+    readonly buttonIconSignal: Signal<string>;
+    private readonly _reszieSyncSub;
+    private readonly _toggleSyncSub;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    viewResized(event: ResizedEvent): void;
+    drawerOpened(opened: boolean): void;
+    toggleDrawer(open?: Maybe<boolean>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxLayoutComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxMapboxLayoutComponent, "dbx-mapbox-layout", never, { "side": { "alias": "side"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "forceHasDrawerContent": { "alias": "forceHasDrawerContent"; "required": false; "isSignal": true; }; "drawerButtonColor": { "alias": "drawerButtonColor"; "required": false; "isSignal": true; }; "openDrawer": { "alias": "openDrawer"; "required": false; "isSignal": true; }; }, { "drawerOpenedChange": "drawerOpenedChange"; }, never, ["[drawer]", "*"], true, never>;
+}
+
+/**
+ * Directive that synchronizes a map's virtual size with the size of the element.
+ */
+declare class DbxMapboxLayoutVirtualResizeSyncComponent {
+    readonly dbxMapboxLayoutComponent: DbxMapboxLayoutComponent;
+    readonly resizedVector$: rxjs.Observable<_dereekb_util.Maybe<Partial<_dereekb_util.Vector>>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxLayoutVirtualResizeSyncComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxMapboxLayoutVirtualResizeSyncComponent, "[dbxMapboxLayoutVirtualResizeSync]", never, {}, {}, never, never, true, never>;
+}
+
+declare class DbxMapboxConfig {
+    readonly defaultStyle?: MapOptions['style'];
+    readonly defaultZoom?: MapboxZoomLevel;
+    readonly defaultCenter?: LatLngPointInput;
+    readonly defaultStoreRefreshPeriod?: number;
+}
+declare const DEFAULT_MAPBOX_STYLE: KnownMapboxStyle;
+declare const DEFAULT_MAPBOX_CENTER: LatLngPointInput;
+declare const DEFAULT_MAPBOX_ZOOM: MapboxZoomLevel;
+declare const DEFAULT_MAPBOX_MAP_STORE_TIMER_REFRESH_PERIOD: Milliseconds;
+declare class DbxMapboxService {
+    private readonly _config;
+    get defaultStyle(): string | MapboxGl.StyleSpecification;
+    get defaultZoom(): MapboxZoomLevel;
+    get defaultCenter(): LatLngPointInput;
+    get mapboxMapStoreTimerRefreshPeriod(): number;
+    initializationOptions(): Partial<MapOptions>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxMapboxService>;
+}
+
+/**
+ * Directive that configures a MapComponent with content from DbxMapboxService. Connects a host MapService to a parent DbxMapboxMapStore if available.
+ */
+declare class DbxMapboxMapDirective {
+    readonly mapService: MapService;
+    readonly mapboxMap: MapComponent;
+    readonly dbxMapboxService: DbxMapboxService;
+    readonly dbxMapboxMapStore: DbxMapboxMapStore | null;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMapDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxMapboxMapDirective, "[dbxMapboxMap]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Content drawer that connects with DbxMapboxMapStore to show the content.
+ */
+declare class DbxMapboxLayoutDrawerComponent {
+    readonly dbxMapboxMapStore: DbxMapboxMapStore;
+    readonly drawerConfigSignal: i0.Signal<_dereekb_util.Maybe<_dereekb_dbx_core.DbxInjectionComponentConfig<unknown>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxLayoutDrawerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxMapboxLayoutDrawerComponent, "dbx-mapbox-layout-drawer", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Directive that connects a host MatMenuTrigger to a DbxMapboxMapStore and listens for right-clicks on the map.
+ *
+ * The map dissapears if the mouse scrolls anywhere else on the map.
+ */
+declare class DbxMapboxMenuComponent {
+    readonly dbxMapboxMapStore: DbxMapboxMapStore;
+    readonly matMenuTrigger: MatMenuTrigger;
+    readonly active: i0.InputSignalWithTransform<boolean, Maybe<boolean>>;
+    readonly openCloseSignal: i0.WritableSignal<Maybe<boolean>>;
+    readonly posSignal: i0.WritableSignal<{
+        x: string;
+        y: string;
+    }>;
+    protected readonly _openCloseEffect: i0.EffectRef;
+    readonly active$: rxjs.Observable<boolean>;
+    protected readonly _sub: SubscriptionObject<rxjs.Unsubscribable>;
+    private readonly _menuCloseSub;
+    private readonly _preventRightClick;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxMapboxMenuComponent, "dbx-mapbox-menu", never, { "active": { "alias": "active"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * DbxMapboxMarkerSize. Numbers are converted to pixels.
+ */
+type DbxMapboxMarkerSize = 'small' | 'medium' | 'large' | 'tall' | Pixels;
+/**
+ * Presentation style.
+ *
+ * - normal: Text under dot with optional icon within dot
+ * - chip: "dbx-chip"-like presentation
+ */
+type DbxMapboxMarkerPresentation = 'normal' | 'chip' | 'chip-small';
+interface DbxMapboxMarkerDisplayConfig {
+    /**
+     * Presentation style. Defaults to "normal"
+     */
+    readonly presentation?: DbxMapboxMarkerPresentation;
+    /**
+     * Additional classes to add to the marker.
+     */
+    readonly markerClasses?: Maybe<CssClassesArray>;
+    /**
+     * Marker icon to display.
+     */
+    readonly icon?: Maybe<string>;
+    /**
+     * Marker label to display.
+     */
+    readonly label?: Maybe<string>;
+    /**
+     * Image URL or Factory that returns an image URL.
+     */
+    readonly image?: Maybe<string | FactoryWithRequiredInput<string, Pixels>>;
+    /**
+     * Size of the marker.
+     */
+    readonly size?: Maybe<DbxMapboxMarkerSize>;
+    /**
+     * ClickableAnchor for the marker.
+     */
+    readonly anchor?: Maybe<ClickableAnchor>;
+    /**
+     * Additional icon content styling. Style is not applied to the entire marker. Use markerClasses instead.
+     */
+    readonly style?: Maybe<CssStyleObject>;
+}
+type DbxMapboxMarker = UniqueModel & LatLngInputRef & DbxMapboxMarkerDisplayConfig;
+/**
+ * MapFunction that converts the input data to a DbxMapboxMarker.
+ */
+type DbxMapboxMarkerFactory<T> = (value: T, index: number) => DbxMapboxMarker;
+/**
+ * Creates the styling for rendering a dot.
+ *
+ * @param background
+ * @param color
+ * @returns
+ */
+declare function dbxMapboxColoredDotStyle(background: string, color?: string): {
+    background: string;
+    padding: string;
+    color: string | undefined;
+    'border-radius': string;
+};
+
+declare class DbxMapboxMarkerComponent implements OnDestroy {
+    private readonly _dbxMapboxChangeService;
+    private static _latLngPoint;
+    readonly marker: i0.InputSignal<Maybe<DbxMapboxMarker>>;
+    readonly latLngSignal: i0.Signal<_dereekb_util.LatLngPoint | undefined>;
+    readonly presentationSignal: i0.Signal<_dereekb_dbx_web_mapbox.DbxMapboxMarkerPresentation>;
+    readonly styleSignal: i0.Signal<any>;
+    readonly presentationCssClassSignal: i0.Signal<string>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMarkerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxMapboxMarkerComponent, "dbx-mapbox-marker", never, { "marker": { "alias": "marker"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Component used to render a set of DbxMapboxMarker values from the input data and marker factory.
+ */
+declare class DbxMapboxMarkersComponent<T> {
+    readonly data: i0.InputSignal<Maybe<T[]>>;
+    readonly markerFactory: i0.InputSignal<Maybe<DbxMapboxMarkerFactory<T>>>;
+    readonly markersSignal: i0.Signal<DbxMapboxMarker[]>;
+    trackMarkerById(index: number, marker: DbxMapboxMarker): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMarkersComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DbxMapboxMarkersComponent<any>, "dbx-mapbox-markers", never, { "data": { "alias": "data"; "required": true; "isSignal": true; }; "markerFactory": { "alias": "markerFactory"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Token used by provideMapboxStoreIfDoesNotExist() to prevent injecting a parent DbxMapboxMapStore into the child view.
+ */
+declare class DbxMapboxMapStoreProviderBlock {
+    readonly dbxMapboxMapStore: DbxMapboxMapStore;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMapStoreProviderBlock, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbxMapboxMapStoreProviderBlock>;
+}
+declare class DbxMapboxMapStoreInjectionBlockDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxMapStoreInjectionBlockDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DbxMapboxMapStoreInjectionBlockDirective, "[dbxMapboxStoreParentBlocker]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * Creates a Provider that initializes a new DbxMapboxMapStore if a parent does not exist.
+ *
+ * If a DbxMapboxMapStoreInjectionBlock is available in the context, and references the same dbxMapboxMapStore that is attempting to be injected, a new DbxMapboxMapStore is created.
+ *
+ * @returns
+ */
+declare function provideMapboxStoreIfParentIsUnavailable(): Provider;
+
+declare class DbxMapboxModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbxMapboxModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DbxMapboxModule, never, [typeof DbxMapboxLayoutVirtualResizeSyncComponent, typeof DbxMapboxMapDirective, typeof DbxMapboxLayoutComponent, typeof DbxMapboxLayoutDrawerComponent, typeof DbxMapboxInjectionComponent, typeof DbxMapboxMenuComponent, typeof DbxMapboxMarkerComponent, typeof DbxMapboxMarkersComponent, typeof DbxMapboxMapStoreInjectionBlockDirective, typeof i10.MapComponent, typeof i10.MarkerComponent], [typeof DbxMapboxLayoutVirtualResizeSyncComponent, typeof DbxMapboxMapDirective, typeof DbxMapboxLayoutComponent, typeof DbxMapboxLayoutDrawerComponent, typeof DbxMapboxInjectionComponent, typeof DbxMapboxMenuComponent, typeof DbxMapboxMarkerComponent, typeof DbxMapboxMarkersComponent, typeof DbxMapboxMapStoreInjectionBlockDirective, typeof i10.MapComponent, typeof i10.MarkerComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DbxMapboxModule>;
+}
+
+/**
+ * Configuration for provideDbxMapbox().
+ */
+interface ProvideDbxMapboxConfig {
+    readonly dbxMapboxConfig: DbxMapboxConfig;
+    readonly ngxMapboxGLModuleConfig: Parameters<typeof provideMapboxGL>[0];
+}
+/**
+ * Creates EnvironmentProviders for providing DbxMapboxConfig and configuring the NgxMapboxGLModule.
+ *
+ * @param config Configuration
+ * @returns EnvironmentProviders
+ */
+declare function provideDbxMapbox(config: ProvideDbxMapboxConfig): EnvironmentProviders;
+
+/**
+ * Convenience type used in .environment.ts files for building configuration.
+ */
+interface DbxMapboxEnvironmentOptions extends DbxMapboxConfig {
+    readonly token: string;
+}
+/**
+ * @deprecated use DbxMapboxEnvironmentOptions instead.
+ */
+type DbxMapboxOptions = DbxMapboxEnvironmentOptions;
+
+export { DEFAULT_MAPBOX_CENTER, DEFAULT_MAPBOX_MAP_STORE_TIMER_REFRESH_PERIOD, DEFAULT_MAPBOX_STYLE, DEFAULT_MAPBOX_ZOOM, DbxMapboxChangeService, DbxMapboxConfig, DbxMapboxInjectionComponent, DbxMapboxInjectionStore, DbxMapboxInjectionStoreInjectionBlockDirective, DbxMapboxInjectionStoreProviderBlock, DbxMapboxLayoutComponent, DbxMapboxLayoutDrawerComponent, DbxMapboxLayoutVirtualResizeSyncComponent, DbxMapboxMapDirective, DbxMapboxMapStore, DbxMapboxMapStoreInjectionBlockDirective, DbxMapboxMapStoreProviderBlock, DbxMapboxMarkerComponent, DbxMapboxMarkersComponent, DbxMapboxMenuComponent, DbxMapboxModule, DbxMapboxService, KNOWN_MAPBOX_STYLES, MAPBOX_MAX_ZOOM_LEVEL, MAPBOX_MIN_ZOOM_LEVEL, dbxMapboxColoredDotStyle, filterByMapboxViewportBound, mapboxViewportBoundFunction, mapboxZoomLevel, provideDbxMapbox, provideMapboxInjectionStoreIfParentIsUnavailable, provideMapboxStoreIfParentIsUnavailable, updateDbxMapboxMapInjectionStoreStateWithInjectionConfig, updateDbxMapboxMapInjectionStoreStateWithRemovedKey };
+export type { DbxMapboxClickEvent, DbxMapboxEnvironmentOptions, DbxMapboxInjectionConfig, DbxMapboxInjectionKey, DbxMapboxLayoutMode, DbxMapboxLayoutSide, DbxMapboxMapInjectionStoreState, DbxMapboxMarginCalculationSizing, DbxMapboxMarker, DbxMapboxMarkerDisplayConfig, DbxMapboxMarkerFactory, DbxMapboxMarkerPresentation, DbxMapboxMarkerSize, DbxMapboxOptions, DbxMapboxStoreBoundRefreshSettings, DbxMapboxStoreBoundRefreshType, DbxMapboxStoreState, FilterMapboxBoundConfig, FilterMapboxBoundReadItemValueFunction, KnownMapboxStyle, MapboxBearing, MapboxEaseTo, MapboxEaseToOptions, MapboxEaseToPositionOptions, MapboxEventData, MapboxFitBounds, MapboxFitBoundsOptions, MapboxFitPositions, MapboxFlyTo, MapboxFlyToOptions, MapboxFlyToPositionOptions, MapboxJumpTo, MapboxJumpToPositionOptions, MapboxMapLifecycleState, MapboxMapMoveState, MapboxMapRotateState, MapboxMapZoomState, MapboxPitch, MapboxResetNorth, MapboxResetNorthPitch, MapboxRotateTo, MapboxSetStyleOptions, MapboxSnapToNorth, MapboxStyleConfig, MapboxTileSize, MapboxViewportBoundFunction, MapboxViewportBoundFunctionConfig, MapboxViewportBoundFunctionInput, MapboxViewportBoundFunctionItem, MapboxViewportBoundFunctionItemValue, MapboxZoomLevel, MapboxZoomLevelRange, ProvideDbxMapboxConfig, StringMapboxListenerPair, TypedMapboxListenerPair };