igniteui-angular-maps 12.1.1

package/lib/igx-geographic-map-component.d.ts

@@ -0,0 +1,231 @@
+import { Type, OnDestroy, EventEmitter, Injector, ComponentFactoryResolver, AfterContentInit, Renderer2, QueryList, NgZone, ViewContainerRef } from '@angular/core';
+import { IgxSeriesComponent } from "igniteui-angular-charts";
+import { IgxSeriesViewerComponent } from "igniteui-angular-charts";
+import { IgRect } from "igniteui-angular-core";
+import { IgPoint } from "igniteui-angular-core";
+import { XamGeographicMap } from './XamGeographicMap';
+import { IgxSeriesCollection } from "igniteui-angular-charts";
+import { IgxImageTilesReadyEventArgs } from './igx-image-tiles-ready-event-args';
+import { IgxNumericXAxisComponent } from "igniteui-angular-charts";
+import { IgxNumericYAxisComponent } from "igniteui-angular-charts";
+import { IgxGeographicMapImagery } from './igx-geographic-map-imagery';
+import { MapResizeBehavior } from './MapResizeBehavior';
+import { MapBackgroundTilingMode } from './MapBackgroundTilingMode';
+export declare const IgxGeographicMapComponent_PROVIDERS: {
+    provide: typeof IgxSeriesViewerComponent;
+    useExisting: Type<any>;
+}[];
+/**
+ * Represents the Infragistics IgxGeographicMapComponent control.
+*/
+export declare class IgxGeographicMapComponent extends IgxSeriesViewerComponent implements AfterContentInit, OnDestroy {
+    private _renderer;
+    private _elRef;
+    private _ngZone;
+    private _componentFactoryResolver;
+    private _injector;
+    contentSeries: QueryList<IgxSeriesComponent>;
+    _dynamicContent: ViewContainerRef;
+    private _height;
+    private _width;
+    height: string;
+    width: string;
+    /**
+     * Gets or sets the legend used for the current chart.
+    */
+    legend: any;
+    /**
+     * The series actually present in the chart. Do not directly modify this array.
+     * This array's contents can be modified by causing Angular to reproject the child content.
+     * Or adding and removing series from the manual series collection on the series property.
+     */
+    actualSeries: IgxSeriesComponent[];
+    private _container;
+    private _series;
+    /**
+     * A collection or manually added series for the chart.
+    */
+    readonly series: IgxSeriesCollection;
+    constructor(_renderer: Renderer2, _elRef: ViewContainerRef, _ngZone: NgZone, _componentFactoryResolver: ComponentFactoryResolver, _injector: Injector);
+    ngOnDestroy(): void;
+    private _wrapper;
+    protected createImplementation(): XamGeographicMap;
+    private _chart;
+    private _dataSource;
+    dataSource: any;
+    bindData(): void;
+    private _seriesAdapter;
+    ngAfterContentInit(): void;
+    private _ensureTooltipCreated;
+    private _defaultTooltips;
+    private _ensureDefaultTooltip;
+    private _onDefaultTooltipsReady;
+    private createTooltip;
+    /**
+     * An imagery to display behind all series, inside the viewport of the IgxGeographicMapComponent control.
+    */
+    backgroundContent: IgxGeographicMapImagery;
+    /**
+                             * @hidden
+                             */
+    readonly i: XamGeographicMap;
+    /**
+ * Gets or sets zoomability of the current control
+*/
+    zoomable: boolean;
+    static ngAcceptInputType_zoomable: boolean | string;
+    /**
+     * Gets or sets the behavior to use during resize.
+    */
+    resizeBehavior: MapResizeBehavior;
+    static ngAcceptInputType_resizeBehavior: MapResizeBehavior | string;
+    /**
+     * Gets or sets if the map should horizontally wrap.
+    */
+    isHorizontalWrappingEnabled: boolean;
+    static ngAcceptInputType_isHorizontalWrappingEnabled: boolean | string;
+    /**
+     * Gets or sets if the map should horizontally wrap.
+    */
+    backgroundTilingMode: MapBackgroundTilingMode;
+    static ngAcceptInputType_backgroundTilingMode: MapBackgroundTilingMode | string;
+    /**
+     * Gets or sets whether to use the uncoerced world rect to constrain the zoom bounds.
+    */
+    useWorldRectForZoomBounds: boolean;
+    static ngAcceptInputType_useWorldRectForZoomBounds: boolean | string;
+    /**
+     * Gets or sets whether skip resetting the zoom when the world rect changes.
+    */
+    suppressZoomResetOnWorldRectChange: boolean;
+    static ngAcceptInputType_suppressZoomResetOnWorldRectChange: boolean | string;
+    /**
+     * Gets or sets the world bounding rectangle.
+    */
+    worldRect: IgRect;
+    static ngAcceptInputType_worldRect: IgRect | string;
+    /**
+     * Gets the actual value of the WorldRect.
+    */
+    actualWorldRect: IgRect;
+    static ngAcceptInputType_actualWorldRect: IgRect | string;
+    /**
+     * The X-axis for this IgxGeographicMap.Component
+     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
+    */
+    xAxis: IgxNumericXAxisComponent;
+    /**
+     * The Y-axis for this IgxGeographicMap.Component
+     * Under normal circumstances, this property should not be set in application code.  By default, it will be set to a numeric axis with a spherical mercator scaler.
+    */
+    yAxis: IgxNumericYAxisComponent;
+    /**
+     * Indicates if this SeriesViewer is a map.
+    */
+    readonly isMap: boolean;
+    static ngAcceptInputType_isMap: boolean | string;
+    /**
+     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
+     * This property is effectively a shortcut to the Width/Height of the WindowRect property.
+    */
+    windowScale: number;
+    static ngAcceptInputType_windowScale: number | string;
+    /**
+     * A number between 0 and 1 determining the scale of the horizontal/vertical zoom.
+     * This property is effectively a shortcut to the Width/Height of the ActualWindowRect property.
+    */
+    actualWindowScale: number;
+    static ngAcceptInputType_actualWindowScale: number | string;
+    /**
+     * Gets whether or not the control is ready for zooming
+    */
+    readonly zoomIsReady: boolean;
+    static ngAcceptInputType_zoomIsReady: boolean | string;
+    findByName(name: string): any;
+    protected _styling(container: any, component: any, parent?: any): void;
+    getCurrentActualWorldRect(): IgRect;
+    /**
+     * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
+    
+    * @param geographic  * The geographic area.
+    */
+    getZoomRectFromGeoRect(geographic: IgRect): IgRect;
+    updateZoomWindow(zoomWindow: IgRect): void;
+    updateWorldRect(worldRect: IgRect): void;
+    /**
+     * Given the current plot area of the control and a geographic region, get the WindowRect that would encompass that geographic region.
+    
+    * @param geographic  * The geographic area.
+    */
+    getZoomFromGeographicRect(geographic: IgRect): IgRect;
+    convertGeographicToZoom(geographic: IgRect, extraPixelPadding: number): IgRect;
+    getZoomFromGeographicPoints(northWest: IgPoint, southEast: IgPoint): IgRect;
+    /**
+     * Given a WindowRect and the current plot area, get the geographic region represented by that WindowRect.
+    
+    * @param windowRect  * The zoom area.
+    */
+    getGeographicFromZoom(windowRect: IgRect): IgRect;
+    /**
+     * Convert a pixel-based coordinate to a geographic coordinate.
+    
+    * @param pixelCoordinate  * A pixel-based coordinate
+    */
+    getGeographicPoint(pixelCoordinate: IgPoint): IgPoint;
+    /**
+     * Convert a geographic coordinate to a pixel-based coordinate.
+    
+    * @param geographicCoordinate  * A geographic coordinate
+    */
+    getPixelPoint(geographicCoordinate: IgPoint): IgPoint;
+    /**
+     * Convert a geographic coordinate to a pixel-based coordinate.
+    
+    * @param geographicCoordinate  * A geographic coordinate
+    */
+    getWindowPoint(geographicCoordinate: IgPoint): IgPoint;
+    /**
+     * Removes all cached tile images from the map imagery assigned to the map's background content.
+    
+    */
+    clearTileCache(): void;
+    /**
+     * Notifies the chart that the CSS styles in effect have been updated.
+    
+    */
+    styleUpdated(): void;
+    /**
+     * Gets actual window scale for horizontal dimension of the control
+    
+    */
+    getActualWindowScaleHorizontal(): number;
+    /**
+     * Gets actual window scale for vertical dimension of the control
+    
+    */
+    getActualWindowScaleVertical(): number;
+    /**
+     * Calls for a deferred refresh to the GeographicMap's background.
+    
+    */
+    deferredRefresh(): void;
+    /**
+     * Returns the chart visuals expressed as a ChartVisualData object.
+    
+    */
+    exportVisualData(): any;
+    /**
+     * Zoom in to the geographic region specified, when possible (may need to wait for map to be initialized).
+    
+    * @param geographic  * The geographic region to zoom to.
+    */
+    zoomToGeographic(geographic: IgRect): void;
+    private _imageTilesReady;
+    /**
+     * This event is fired whenever the image tiles transition from a loading state (e.g. some are fading in) to a loaded state.
+    */
+    readonly imageTilesReady: EventEmitter<{
+        sender: any;
+        args: IgxImageTilesReadyEventArgs;
+    }>;
+}

package/lib/igx-geographic-map-core-dynamic-module.d.ts

@@ -0,0 +1,3 @@
+export declare class IgxGeographicMapCoreDynamicModule {
+    constructor();
+}

package/lib/igx-geographic-map-core-module.d.ts

@@ -0,0 +1,3 @@
+export declare class IgxGeographicMapCoreModule {
+    constructor();
+}

package/lib/igx-geographic-map-dynamic-module.d.ts

@@ -0,0 +1,2 @@
+export declare class IgxGeographicMapDynamicModule {
+}

package/lib/igx-geographic-map-imagery.d.ts

@@ -0,0 +1,92 @@
+import { EventEmitter } from '@angular/core';
+import { IgRect } from "igniteui-angular-core";
+import { IgxGeographicMapComponent } from "./igx-geographic-map-component";
+import { IgxImageTilesReadyEventArgs } from "./igx-image-tiles-ready-event-args";
+import { IgxImagesChangedEventArgs } from "./igx-images-changed-event-args";
+import { IgxCancellingMultiScaleImageEventArgs } from "igniteui-angular-core";
+import { IgxDownloadingMultiScaleImageEventArgs } from "igniteui-angular-core";
+import { GeographicMapImagery as GeographicMapImagery_internal } from "./GeographicMapImagery";
+import { IMapRenderDeferralHandler } from "igniteui-angular-core";
+/**
+ * Control class used for displaying multi-scale TileSource imagery.  Designed to be used for background imagery in the IgxGeographicMap.Component
+*/
+export declare abstract class IgxGeographicMapImagery {
+    protected createImplementation(): GeographicMapImagery_internal;
+    protected _implementation: any;
+    /**
+     * @hidden
+     */
+    readonly i: GeographicMapImagery_internal;
+    private onImplementationCreated;
+    constructor();
+    protected _provideImplementation(i: any): void;
+    /**
+     * The deferral handler to use for deferred refreshes.
+    */
+    deferralHandler: IMapRenderDeferralHandler;
+    /**
+     * A rectangle representing the portion of the map imagery currently in view.
+     * A rectangle at X=0, Y=0 with a Height and Width of 1 implies the entire plotting area is in view.  A Height and Width of .5 would imply that the view is halfway zoomed in.
+    */
+    windowRect: IgRect;
+    static ngAcceptInputType_windowRect: IgRect | string;
+    /**
+     * The IgxGeographicMapComponent which is hosting this GeographicMapImagery control.
+    */
+    geographicMap: IgxGeographicMapComponent;
+    /**
+     * Gets or sets the referer sent in the headers of the tile request.
+    */
+    referer: string;
+    /**
+     * Gets or sets if horizontal wrapping is enabled for the imagery.
+    */
+    isHorizontalWrappingEnabled: boolean;
+    static ngAcceptInputType_isHorizontalWrappingEnabled: boolean | string;
+    /**
+     * Gets or sets the UserAgent sent in the headers of the tile request.
+    */
+    userAgent: string;
+    opacity: number;
+    static ngAcceptInputType_opacity: number | string;
+    findByName(name: string): any;
+    /**
+     * Removes all cached tile Imagery from the
+    
+    */
+    clearTileCache(): void;
+    private _imageTilesReady;
+    /**
+     * Event raised when the image tiles have been downloaded.
+    */
+    readonly imageTilesReady: EventEmitter<{
+        sender: any;
+        args: IgxImageTilesReadyEventArgs;
+    }>;
+    private _imagesChanged;
+    /**
+     * Event raised when tile images have changed.
+    */
+    readonly imagesChanged: EventEmitter<{
+        sender: any;
+        args: IgxImagesChangedEventArgs;
+    }>;
+    private _cancellingImage;
+    /**
+     * Event raised when an image is being downloaded.
+    */
+    readonly cancellingImage: EventEmitter<{
+        sender: any;
+        args: IgxCancellingMultiScaleImageEventArgs;
+    }>;
+    private _downloadingImage;
+    /**
+     * Event raised when an image is being downloaded.
+    */
+    readonly downloadingImage: EventEmitter<{
+        sender: any;
+        args: IgxDownloadingMultiScaleImageEventArgs;
+    }>;
+    protected _zoneRunner: (act: () => void) => void;
+    protected _runInZone(act: () => void): void;
+}

package/lib/igx-geographic-map-module.d.ts

@@ -0,0 +1,2 @@
+export declare class IgxGeographicMapModule {
+}

package/lib/igx-geographic-map-series-host-component.d.ts

@@ -0,0 +1,83 @@
+import { Type } from '@angular/core';
+import { IgRect } from "igniteui-angular-core";
+import { IgPoint } from "igniteui-angular-core";
+import { IgxSeriesComponent } from "igniteui-angular-charts";
+import { GeographicMapSeriesHost } from "./GeographicMapSeriesHost";
+/**
+ * Base class for hosting chart series in a IgxGeographicMap.Component
+*/
+export declare const IgxGeographicMapSeriesHostComponent_PROVIDERS: {
+    provide: typeof IgxSeriesComponent;
+    useExisting: Type<any>;
+}[];
+export declare abstract class IgxGeographicMapSeriesHostComponent extends IgxSeriesComponent {
+    /**
+                                 * @hidden
+                                 */
+    readonly i: GeographicMapSeriesHost;
+    constructor();
+    /**
+     * Checks if this control is geographic coordinate system
+    */
+    readonly isGeographic: boolean;
+    static ngAcceptInputType_isGeographic: boolean | string;
+    readonly hasMarkers: boolean;
+    static ngAcceptInputType_hasMarkers: boolean | string;
+    /**
+     * The minimum scale at which this series becomes visible.
+     * The default value for this property is 1.0, which means the series will always be visible.  At a VisibleFromScale setting of 0.0, the series will never be visible.  At a VisibleFromScale setting of 0.5, the series will be visible as long as the map is zoomed in to at least 200%.
+    */
+    visibleFromScale: number;
+    static ngAcceptInputType_visibleFromScale: number | string;
+    /**
+     * Gets or sets the coercion methods to use when loading data from data sources.
+     * Should be specified before setting any member paths, if being used. Setting it later
+     * will not cause data to be reimported into the chart.
+    */
+    coercionMethods: any;
+    getItemValue(item: any, memberPathName: string): any;
+    /**
+     * Gets the item that is the best match for the specified world coordinates.
+    
+    * @param world  * The world coordinates to use.
+    */
+    getItem(world: IgPoint): any;
+    getPreviousOrExactIndex(world: IgPoint, skipUnknowns: boolean): number;
+    getNextOrExactIndex(world: IgPoint, skipUnknowns: boolean): number;
+    getSeriesValue(world: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): number;
+    getSeriesValuePosition(world: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): IgPoint;
+    /**
+     * If possible, will return the best available value bounding box within the series that has the best value match for the world position provided.
+    
+    * @param world  * The world coordinate for which to get a value bounding box for
+    */
+    getSeriesValueBoundingBox(world: IgPoint): IgRect;
+    /**
+     * If possible, will return the best available value marker bounding box within the series that has the best value match for the world position provided.
+    
+    * @param world  * The world coordinates for which to get a value marker bounding box for
+    */
+    getSeriesValueMarkerBoundingBox(world: IgPoint): IgRect;
+    getSeriesHighValue(world: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): number;
+    getSeriesHighValuePosition(world: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): IgPoint;
+    getSeriesLowValue(world: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): number;
+    getSeriesLowValuePosition(world: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): IgPoint;
+    getSeriesValuePositionFromSeriesPixel(mouse: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): IgPoint;
+    getSeriesValueFromSeriesPixel(mouse: IgPoint, useInterpolation: boolean, skipUnknowns: boolean): number;
+    /**
+     * For a category plotted series, returns the current width of the items within the categories. This only returns a value if the items have some form of width (e.g. columns, bars, etc.) otherwise 0 is returned.
+    
+    */
+    getItemSpan(): number;
+    /**
+     * Renders the series.
+    
+    * @param animate  * True if the change should be animated.
+    */
+    renderSeries(animate: boolean): void;
+    /**
+     * Called when this series' Style is updated.
+    
+    */
+    styleUpdated(): void;
+}

package/lib/igx-geographic-polyline-series-component.d.ts

@@ -0,0 +1,48 @@
+import { Type, EventEmitter } from '@angular/core';
+import { IgxStyleShapeEventArgs } from "igniteui-angular-charts";
+import { IgxGeographicShapeSeriesBaseComponent } from "./igx-geographic-shape-series-base-component";
+import { IgxGeographicMapSeriesHostComponent } from "./igx-geographic-map-series-host-component";
+import { IgxSeriesComponent } from "igniteui-angular-charts";
+import { GeographicPolylineSeries } from "./GeographicPolylineSeries";
+/**
+ * Series class used for displaying multiple polylines, in a geographic context, for datasources which contain multiple lists of points.
+*/
+export declare const IgxGeographicPolylineSeriesComponent_PROVIDERS: ({
+    provide: typeof IgxGeographicMapSeriesHostComponent;
+    useExisting: Type<any>;
+} | {
+    provide: typeof IgxSeriesComponent;
+    useExisting: Type<any>;
+})[];
+export declare class IgxGeographicPolylineSeriesComponent extends IgxGeographicShapeSeriesBaseComponent {
+    protected createImplementation(): GeographicPolylineSeries;
+    /**
+                                 * @hidden
+                                 */
+    readonly i: GeographicPolylineSeries;
+    constructor();
+    /**
+     * Gets or sets the fill brush.
+    */
+    shapeFill: string;
+    /**
+     * Gets or sets the stroke brush.
+    */
+    shapeStroke: string;
+    /**
+     * Gets or sets the stroke thickness.
+    */
+    shapeStrokeThickness: number;
+    static ngAcceptInputType_shapeStrokeThickness: number | string;
+    /**
+     * Gets or sets the opacity.
+    */
+    shapeOpacity: number;
+    static ngAcceptInputType_shapeOpacity: number | string;
+    ensureShapeStyle(): void;
+    private _styleShape;
+    readonly styleShape: EventEmitter<{
+        sender: any;
+        args: IgxStyleShapeEventArgs;
+    }>;
+}

package/lib/igx-geographic-polyline-series-dynamic-module.d.ts

@@ -0,0 +1,3 @@
+export declare class IgxGeographicPolylineSeriesDynamicModule {
+    constructor();
+}

package/lib/igx-geographic-polyline-series-module.d.ts

@@ -0,0 +1,2 @@
+export declare class IgxGeographicPolylineSeriesModule {
+}

package/lib/igx-geographic-proportional-symbol-series-base-component.d.ts

@@ -0,0 +1,18 @@
+import { Type } from '@angular/core';
+import { IgxGeographicMapSeriesHostComponent } from "./igx-geographic-map-series-host-component";
+import { IgxSeriesComponent } from "igniteui-angular-charts";
+import { GeographicProportionalSymbolSeriesBase } from "./GeographicProportionalSymbolSeriesBase";
+export declare const IgxGeographicProportionalSymbolSeriesBaseComponent_PROVIDERS: ({
+    provide: typeof IgxGeographicMapSeriesHostComponent;
+    useExisting: Type<any>;
+} | {
+    provide: typeof IgxSeriesComponent;
+    useExisting: Type<any>;
+})[];
+export declare abstract class IgxGeographicProportionalSymbolSeriesBaseComponent extends IgxGeographicMapSeriesHostComponent {
+    /**
+                                 * @hidden
+                                 */
+    readonly i: GeographicProportionalSymbolSeriesBase;
+    constructor();
+}

package/lib/igx-geographic-proportional-symbol-series-component.d.ts

@@ -0,0 +1,168 @@
+import { Type, EventEmitter } from '@angular/core';
+import { IgDataTemplate } from "igniteui-angular-core";
+import { MarkerType } from "igniteui-angular-charts";
+import { MarkerOutlineMode } from "igniteui-angular-charts";
+import { MarkerFillMode } from "igniteui-angular-charts";
+import { IgxSizeScaleComponent } from "igniteui-angular-charts";
+import { IgxBrushScaleComponent } from "igniteui-angular-charts";
+import { ScatterItemSearchMode } from "igniteui-angular-charts";
+import { IgxAssigningScatterStyleEventArgs } from "igniteui-angular-charts";
+import { IgxAssigningScatterMarkerStyleEventArgs } from "igniteui-angular-charts";
+import { IgxGeographicMapSeriesHostComponent } from "./igx-geographic-map-series-host-component";
+import { IgxSeriesComponent } from "igniteui-angular-charts";
+import { GeographicProportionalSymbolSeries } from "./GeographicProportionalSymbolSeries";
+/**
+ * Series class for a geographic map with points marked at given locations.
+ * This is the geographic equivalent of a ScatterSeries.
+*/
+export declare const IgxGeographicProportionalSymbolSeriesComponent_PROVIDERS: ({
+    provide: typeof IgxGeographicMapSeriesHostComponent;
+    useExisting: Type<any>;
+} | {
+    provide: typeof IgxSeriesComponent;
+    useExisting: Type<any>;
+})[];
+export declare class IgxGeographicProportionalSymbolSeriesComponent extends IgxGeographicMapSeriesHostComponent {
+    protected createImplementation(): GeographicProportionalSymbolSeries;
+    /**
+                                 * @hidden
+                                 */
+    readonly i: GeographicProportionalSymbolSeries;
+    constructor();
+    /**
+     * The name of the property of ItemsSource items which contains the latitude coordinate of the symbol.
+    */
+    latitudeMemberPath: string;
+    /**
+     * The name of the property of ItemsSource items which contains the longitude coordinate of the symbol.
+    */
+    longitudeMemberPath: string;
+    /**
+     * Gets or sets the marker type for the current series object.
+     * If the MarkerTemplate property is set, the setting of the MarkerType property will be ignored.
+    */
+    markerType: MarkerType;
+    static ngAcceptInputType_markerType: MarkerType | string;
+    /**
+     * Gets or sets whether the marker outline is based on the marker brush of the series rather than the marker outlines collection.
+    */
+    markerOutlineMode: MarkerOutlineMode;
+    static ngAcceptInputType_markerOutlineMode: MarkerOutlineMode | string;
+    /**
+     * Gets or sets whether the marker fill is based on the marker outline of the series rather than the marker brushes collection.
+    */
+    markerFillMode: MarkerFillMode;
+    static ngAcceptInputType_markerFillMode: MarkerFillMode | string;
+    /**
+     * Gets or sets the MarkerTemplate for the current series object.
+    */
+    markerTemplate: IgDataTemplate;
+    /**
+     * Gets or sets the brush that specifies how the current series object's marker interiors are painted.
+    */
+    markerBrush: string;
+    /**
+     * Gets or sets the brush that specifies how the current series object's marker outlines are painted.
+    */
+    markerOutline: string;
+    /**
+     * Gets or sets the maximum number of markerItems displayed by the current series.
+     * If more than the specified number of markerItems are visible, the series will automatically
+     * choose a representative set.
+    */
+    maximumMarkers: number;
+    static ngAcceptInputType_maximumMarkers: number | string;
+    /**
+     * Gets or sets the radius mapping property for the current series object.
+    */
+    radiusMemberPath: string;
+    /**
+     * Gets or sets the radius size scale for the bubbles.
+    */
+    radiusScale: IgxSizeScaleComponent;
+    /**
+     * Gets or sets the Label mapping property for the current series object.
+    */
+    labelMemberPath: string;
+    /**
+     * Gets or sets the fill mapping property for the current series object.
+    */
+    fillMemberPath: string;
+    /**
+     * Gets or sets the brush scale for the marker brush.
+    */
+    fillScale: IgxBrushScaleComponent;
+    /**
+     * Gets or sets the whether or not the FillScale uses global values of FillMemberPath of multiple series.
+     * This setting applies only if multiple series are using the same FillScale.
+    */
+    fillScaleUseGlobalValues: boolean;
+    static ngAcceptInputType_fillScaleUseGlobalValues: boolean | string;
+    /**
+     * Gets or sets whether or not the marker outline should use FillScale like the marker fill does.
+     * This setting applies only if the current series has a FillScale set and it overrides MarkerOutline setting.
+    */
+    markerOutlineUsesFillScale: boolean;
+    static ngAcceptInputType_markerOutlineUsesFillScale: boolean | string;
+    /**
+     * Gets or sets brightness of the marker outline. Using negative value will change marker outline to darker color and positive value will change marker outline to brighter color
+     * Note you can use any values between minimum value of -1 (darkest outline) and maximum value of 1 (brightest outline)
+    */
+    markerOutlineBrightness: number;
+    static ngAcceptInputType_markerOutlineBrightness: number | string;
+    /**
+     * Gets or sets brightness of the marker fill. Using negative value will change marker fill to darker color and positive value will change marker fill to brighter color
+     * Note you can use any values between minimum value of -1 (darkest fill) and maximum value of 1 (brightest fill)
+    */
+    markerBrushBrightness: number;
+    static ngAcceptInputType_markerBrushBrightness: number | string;
+    /**
+     * Gets or sets thickness of the marker outline
+    */
+    markerThickness: number;
+    static ngAcceptInputType_markerThickness: number | string;
+    /**
+     * Gets or sets the whether or not the RadiusScale uses global values of RadiusMemberPath of multiple series.
+     * This setting applies only if multiple series are using the same RadiusScale.
+    */
+    radiusScaleUseGlobalValues: boolean;
+    static ngAcceptInputType_radiusScaleUseGlobalValues: boolean | string;
+    /**
+     * Gets or sets whether this Scatter series should allow custom style overrides of its individual visuals.
+    */
+    isCustomScatterStyleAllowed: boolean;
+    static ngAcceptInputType_isCustomScatterStyleAllowed: boolean | string;
+    /**
+     * Gets or sets whether this Scatter series should allow custom style overrides of its individual marker visuals.
+    */
+    isCustomScatterMarkerStyleAllowed: boolean;
+    static ngAcceptInputType_isCustomScatterMarkerStyleAllowed: boolean | string;
+    /**
+     * Gets or sets the mode the series will use to find the closest point to the cursor.
+    */
+    itemSearchMode: ScatterItemSearchMode;
+    static ngAcceptInputType_itemSearchMode: ScatterItemSearchMode | string;
+    /**
+     * Gets or sets the threshold to use when searching for items using ItemSearchMode.
+    */
+    itemSearchThreshold: number;
+    static ngAcceptInputType_itemSearchThreshold: number | string;
+    findByName(name: string): any;
+    protected _styling(container: any, component: any, parent?: any): void;
+    private _assigningScatterStyle;
+    /**
+     * Event raised when Assigning Category Style
+    */
+    readonly assigningScatterStyle: EventEmitter<{
+        sender: any;
+        args: IgxAssigningScatterStyleEventArgs;
+    }>;
+    private _assigningScatterMarkerStyle;
+    /**
+     * Event raised when Assigning Scatter Marker Style
+    */
+    readonly assigningScatterMarkerStyle: EventEmitter<{
+        sender: any;
+        args: IgxAssigningScatterMarkerStyleEventArgs;
+    }>;
+}

package/lib/igx-geographic-proportional-symbol-series-dynamic-module.d.ts

@@ -0,0 +1,3 @@
+export declare class IgxGeographicProportionalSymbolSeriesDynamicModule {
+    constructor();
+}

package/lib/igx-geographic-proportional-symbol-series-module.d.ts

@@ -0,0 +1,2 @@
+export declare class IgxGeographicProportionalSymbolSeriesModule {
+}