@carto/kepler.gl 0.0.80 → 0.1.0-alpha.0

package/dist/actions/vis-state-actions.d.ts

@@ -0,0 +1,821 @@
+import ActionTypes from 'constants/action-types';
+import { AddDataToMapPayload } from '../actions/actions';
+import { FileCacheItem } from '../processors/types';
+import { Layer, LayerBaseConfig, LayerVisConfig } from 'layers';
+import { Feature, InteractionConfig } from 'reducers/vis-state-updaters';
+import { ValueOf, Merge, RGBColor, NestedPartial } from '../reducers/types';
+import { ColorUI } from 'layers/layer-factory';
+export type LayerConfigChangeUpdaterAction = {
+    oldLayer: Layer;
+    newConfig: Partial<LayerBaseConfig>;
+};
+/**
+ * Update layer base config: dataId, label, column, isVisible
+ * @param oldLayer - layer to be updated
+ * @param newConfig - new config to be merged with old config
+ * @returns action
+ * @public
+ */
+export declare function layerConfigChange(oldLayer: Layer, newConfig: Partial<LayerBaseConfig>): Merge<LayerConfigChangeUpdaterAction, {
+    type: typeof ActionTypes.LAYER_CONFIG_CHANGE;
+}>;
+export type LayerTextLabelChangeUpdaterAction = {
+    oldLayer: Layer;
+    idx: number | 'all';
+    prop: string;
+    value: any;
+};
+/**
+ * Update layer text label
+ * @param oldLayer - layer to be updated
+ * @param idx -`idx` of text label to be updated
+ * @param prop - `prop` of text label, e,g, `anchor`, `alignment`, `color`, `size`, `field`
+ * @param value - new value
+ * @returns action
+ * @public
+ */
+export declare function layerTextLabelChange(oldLayer: Layer, idx: number | 'all', prop: string, value: any): Merge<LayerTextLabelChangeUpdaterAction, {
+    type: typeof ActionTypes.LAYER_TEXT_LABEL_CHANGE;
+}>;
+export type LayerTypeChangeUpdaterAction = {
+    oldLayer: Layer;
+    newType: string;
+};
+/**
+ * Update layer type. Previews layer config will be copied if applicable.
+ * @param oldLayer - layer to be updated
+ * @param newType - new type
+ * @returns action
+ * @public
+ */
+export declare function layerTypeChange(oldLayer: Layer, newType: string): Merge<LayerTypeChangeUpdaterAction, {
+    type: typeof ActionTypes.LAYER_TYPE_CHANGE;
+}>;
+export type LayerVisualChannelConfigChangeUpdaterAction = {
+    oldLayer: Layer;
+    newConfig: Partial<LayerBaseConfig>;
+    channel: string;
+};
+/**
+ * Update layer visual channel
+ * @memberof visStateActions
+ * @param oldLayer - layer to be updated
+ * @param newConfig - new visual channel config
+ * @param channel - channel to be updated
+ * @returns action
+ * @public
+ */
+export declare function layerVisualChannelConfigChange(oldLayer: Layer, newConfig: Partial<LayerBaseConfig>, channel: string): Merge<LayerVisualChannelConfigChangeUpdaterAction, {
+    type: typeof ActionTypes.LAYER_VISUAL_CHANNEL_CHANGE;
+}>;
+export type LayerVisConfigChangeUpdaterAction = {
+    oldLayer: Layer;
+    newVisConfig: Partial<LayerVisConfig>;
+};
+/**
+ * Update layer `visConfig`
+ * @memberof visStateActions
+ * @param oldLayer - layer to be updated
+ * @param newVisConfig - new visConfig as a key value map: e.g. `{opacity: 0.8}`
+ * @returns action
+ * @public
+ */
+export declare function layerVisConfigChange(oldLayer: Layer, newVisConfig: Partial<LayerVisConfig>): Merge<LayerVisConfigChangeUpdaterAction, {
+    type: typeof ActionTypes.LAYER_VIS_CONFIG_CHANGE;
+}>;
+export type LayerColorUIChangeUpdaterAction = {
+    oldLayer: Layer;
+    prop: string;
+    newConfig: NestedPartial<ColorUI>;
+};
+/**
+ * Set the color palette ui for layer color
+ * @memberof visStateActions
+ * @param oldLayer - layer to be updated
+ * @param prop - which color prop
+ * @param newConfig - to be merged
+ * @returns action
+ * @public
+ */
+export declare function layerColorUIChange(oldLayer: Layer, prop: string, newConfig: NestedPartial<ColorUI>): Merge<LayerColorUIChangeUpdaterAction, {
+    type: typeof ActionTypes.LAYER_COLOR_UI_CHANGE;
+}>;
+export type UpdateLayerBlendingUpdaterAction = {
+    mode: 'additive' | 'normal' | 'subtractive';
+};
+/**
+ * Update layer blending mode
+ * @memberof visStateActions
+ * @param mode one of `additive`, `normal` and `subtractive`
+ * @returns action
+ * @public
+ */
+export declare function updateLayerBlending(mode: 'additive' | 'normal' | 'subtractive'): Merge<UpdateLayerBlendingUpdaterAction, {
+    type: typeof ActionTypes.UPDATE_LAYER_BLENDING;
+}>;
+export type InteractionConfigChangeUpdaterAction = {
+    config: ValueOf<InteractionConfig>;
+};
+/**
+ * Update `interactionConfig`
+ * @memberof visStateActions
+ * @param config - new config as key value map: `{tooltip: {enabled: true}}`
+ * @returns action
+ * @public
+ */
+export declare function interactionConfigChange(config: ValueOf<InteractionConfig>): Merge<InteractionConfigChangeUpdaterAction, {
+    type: typeof ActionTypes.INTERACTION_CONFIG_CHANGE;
+}>;
+export type SetFilterUpdaterAction = {
+    idx: number;
+    prop: string;
+    value: any;
+    valueIndex?: number;
+};
+/**
+ * Update filter property
+ * @memberof visStateActions
+ * @param idx -`idx` of filter to be updated
+ * @param prop - `prop` of filter, e,g, `dataId`, `name`, `value`
+ * @param value - new value
+ * @param valueIndex - dataId index
+ * @returns action
+ * @public
+ */
+export declare function setFilter(idx: number, prop: string, value: any, valueIndex?: number): Merge<SetFilterUpdaterAction, {
+    type: typeof ActionTypes.SET_FILTER;
+}>;
+export type SetFilterAnimationTimeUpdaterAction = {
+    idx: number;
+    prop: string;
+    value: any;
+    valueIndex?: number;
+};
+/**
+ * Same as Update filter
+ * @memberof visStateActions
+ * @param idx -`idx` of filter to be updated
+ * @param prop - `prop` of filter, e,g, `dataId`, `name`, `value`
+ * @param value - new value
+ * @param valueIndex - dataId index
+ * @returns action
+ * @public
+ */
+export declare function setFilterAnimationTime(idx: number, prop: string, value: any, valueIndex?: number): Merge<SetFilterAnimationTimeUpdaterAction, {
+    type: typeof ActionTypes.SET_FILTER_ANIMATION_TIME;
+}>;
+export type SetFilterAnimationWindowUpdaterAction = {
+    id: string;
+    animationWindow: string;
+};
+/**
+ * Same as Update filter
+ * @memberof visStateActions
+ * @public
+ */
+export declare function setFilterAnimationWindow({ id, animationWindow }: SetFilterAnimationWindowUpdaterAction): Merge<SetFilterAnimationWindowUpdaterAction, {
+    type: typeof ActionTypes.SET_FILTER_ANIMATION_WINDOW;
+}>;
+export type AddFilterUpdaterAction = {
+    dataId?: string | null;
+};
+/**
+ * Add a new filter
+ * @memberof visStateActions
+ * @param dataId - dataset `id` this new filter is associated with
+ * @returns action
+ * @public
+ */
+export declare function addFilter(dataId: string | null): Merge<AddFilterUpdaterAction, {
+    type: typeof ActionTypes.ADD_FILTER;
+}>;
+export type AddLayerUpdaterAction = {
+    config?: object;
+    datasetId?: string;
+};
+/**
+ * Add a new layer
+ * @memberof visStateActions
+ * @param config - new layer config
+ * @param datasetId - dataset id used for creating an empty layer
+ * @returns action
+ * @public
+ */
+export declare function addLayer(config?: object, datasetId?: string): Merge<AddLayerUpdaterAction, {
+    type: typeof ActionTypes.ADD_LAYER;
+}>;
+export type ReorderLayerUpdaterAction = {
+    order: number[];
+};
+/**
+ * Reorder layer, order is an array of layer indexes, index 0 will be the one at the bottom
+ * @memberof visStateActions
+ * @param order an array of layer indexes
+ * @returns action
+ * @public
+ * @example
+ *
+ * // bring `layers[1]` below `layers[0]`, the sequence layers will be rendered is `1`, `0`, `2`, `3`.
+ * // `1` will be at the bottom, `3` will be at the top.
+ * this.props.dispatch(reorderLayer([1, 0, 2, 3]));
+ */
+export declare function reorderLayer(order: number[]): Merge<ReorderLayerUpdaterAction, {
+    type: typeof ActionTypes.REORDER_LAYER;
+}>;
+export type RemoveFilterUpdaterAction = {
+    idx: number;
+};
+/**
+ * Remove a filter from `visState.filters`, once a filter is removed, data will be re-filtered and layer will be updated
+ * @memberof visStateActions
+ * @param idx idx of filter to be removed
+ * @returns action
+ * @public
+ */
+export declare function removeFilter(idx: number): Merge<RemoveFilterUpdaterAction, {
+    type: typeof ActionTypes.REMOVE_FILTER;
+}>;
+export type RemoveLayerUpdaterAction = {
+    idx: number;
+};
+/**
+ * Remove a layer
+ * @memberof visStateActions
+ * @param idx idx of layer to be removed
+ * @returns action
+ * @public
+ */
+export declare function removeLayer(idx: number): Merge<RemoveLayerUpdaterAction, {
+    type: typeof ActionTypes.REMOVE_LAYER;
+}>;
+export type DuplicateLayerUpdaterAction = {
+    idx: number;
+};
+/**
+ * Duplicate a layer
+ * @memberof visStateActions
+ * @param idx idx of layer to be duplicated
+ * @returns action
+ * @public
+ */
+export declare function duplicateLayer(idx: number): Merge<DuplicateLayerUpdaterAction, {
+    type: typeof ActionTypes.DUPLICATE_LAYER;
+}>;
+export type RemoveDatasetUpdaterAction = {
+    dataId: string;
+};
+/**
+ * Remove a dataset and all layers, filters, tooltip configs that based on it
+ * @memberof visStateActions
+ * @param dataId dataset id
+ * @returns action
+ * @public
+ */
+export declare function removeDataset(dataId: string): Merge<RemoveDatasetUpdaterAction, {
+    type: typeof ActionTypes.REMOVE_DATASET;
+}>;
+export type ShowDatasetTableUpdaterAction = {
+    dataId: string;
+};
+/**
+ * Display dataset table in a modal
+ * @memberof visStateActions
+ * @param dataId dataset id to show in table
+ * @returns action
+ * @public
+ */
+export declare function showDatasetTable(dataId: string): Merge<ShowDatasetTableUpdaterAction, {
+    type: typeof ActionTypes.SHOW_DATASET_TABLE;
+}>;
+export type UpdateDatasetColorUpdater = {
+    dataId: string;
+    newColor: RGBColor;
+};
+/**
+ * Update dataset color to custom by means of color picker
+ * @memberof visStateActions
+ * @param dataId dataset `id` this custom color is associated with
+ * @param newColor custom color in RGBformat
+ * @returns action
+ * @public
+ */
+export declare function updateTableColor(dataId: string, newColor: RGBColor): Merge<UpdateDatasetColorUpdater, {
+    type: typeof ActionTypes.UPDATE_TABLE_COLOR;
+}>;
+export type SortTableColumnUpdaterAction = {
+    dataId: string;
+    column: string;
+    mode?: string;
+};
+/**
+ * Sort dataset column, for table display
+ * @memberof visStateActions
+ * @param dataId
+ * @param column
+ * @param mode
+ * @returns action
+ * @public
+ */
+export declare function sortTableColumn(dataId: string, column: string, mode?: string): Merge<SortTableColumnUpdaterAction, {
+    type: typeof ActionTypes.SORT_TABLE_COLUMN;
+}>;
+export type PinTableColumnUpdaterAction = {
+    dataId: string;
+    column: string;
+};
+/**
+ * Pin dataset column, for table display
+ * @param dataId
+ * @param column
+ * @returns action
+ * @public
+ */
+export declare function pinTableColumn(dataId: string, column: string): Merge<PinTableColumnUpdaterAction, {
+    type: typeof ActionTypes.PIN_TABLE_COLUMN;
+}>;
+export type CopyTableColumnUpdaterAction = {
+    dataId: string;
+    column: string;
+};
+/**
+ * Copy column, for table display
+ * @param dataId
+ * @param column
+ * @returns action
+ * @public
+ */
+export declare function copyTableColumn(dataId: string, column: string): Merge<CopyTableColumnUpdaterAction, {
+    type: typeof ActionTypes.COPY_TABLE_COLUMN;
+}>;
+export type AddDataToMapUpdaterOptions = {
+    centrMap?: boolean;
+    readOnly?: boolean;
+    keepExistingConfig?: boolean;
+};
+export type UpdateVisDataUpdaterAction = {
+    datasets: AddDataToMapPayload['datasets'];
+    options: AddDataToMapPayload['options'];
+    config: AddDataToMapPayload['config'];
+} & AddDataToMapPayload;
+/**
+ * Add new dataset to `visState`, with option to load a map config along with the datasets
+ * @memberof visStateActions
+ * @param datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param {object} options
+ * @param options.centerMap `default: true` if `centerMap` is set to `true` kepler.gl will
+ * place the map view within the data points boundaries
+ * @param options.readOnly `default: false` if `readOnly` is set to `true`
+ * the left setting panel will be hidden
+ * @param config this object will contain the full kepler.gl instance configuration {mapState, mapStyle, visState}
+ * @returns action
+ * @public
+ */
+export declare function updateVisData(datasets: AddDataToMapPayload['datasets'], options: AddDataToMapPayload['options'], config: AddDataToMapPayload['config']): Merge<UpdateVisDataUpdaterAction, {
+    type: typeof ActionTypes.UPDATE_VIS_DATA;
+}>;
+export type RenameDatasetUpdaterAction = {
+    dataId: string;
+    label: string;
+};
+/**
+ * Rename an existing dataset in `visState`
+ * @memberof visStateActions
+ * @param dataId - ***required** Id of the dataset to update
+ * @param label - ***required** New name for the dataset
+ * @returns action
+ * @public
+ */
+export declare function renameDataset(dataId: string, label: string): Merge<RenameDatasetUpdaterAction, {
+    type: typeof ActionTypes.RENAME_DATASET;
+}>;
+export type ToggleFilterAnimationUpdaterAction = {
+    idx: number;
+};
+/**
+ * Start and end filter animation
+ * @memberof visStateActions
+ * @param {Number} idx of filter
+ * @returns action
+ * @public
+ */
+export declare function toggleFilterAnimation(idx: number): Merge<ToggleFilterAnimationUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_FILTER_ANIMATION;
+}>;
+export type UpdateFilterAnimationSpeedUpdaterAction = {
+    idx: number;
+    speed: number;
+};
+/**
+ * Change filter animation speed
+ * @memberof visStateActions
+ * @param idx -  `idx` of filter
+ * @param speed - `speed` to change it to. `speed` is a multiplier
+ * @returns action
+ * @public
+ */
+export declare function updateFilterAnimationSpeed(idx: number, speed: number): Merge<UpdateFilterAnimationSpeedUpdaterAction, {
+    type: typeof ActionTypes.UPDATE_FILTER_ANIMATION_SPEED;
+}>;
+export type SetLayerAnimationTimeUpdaterAction = {
+    value: number;
+};
+/**
+ * Reset animation
+ * @memberof visStateActions
+ * @param value -  Current value of the slider
+ * @returns action
+ * @public
+ */
+export declare function setLayerAnimationTime(value: number): Merge<SetLayerAnimationTimeUpdaterAction, {
+    type: typeof ActionTypes.SET_LAYER_ANIMATION_TIME;
+}>;
+export type UpdateLayerAnimationSpeedUpdaterAction = {
+    speed: number;
+};
+/**
+ * update trip layer animation speed
+ * @memberof visStateActions
+ * @param speed - `speed` to change it to. `speed` is a multiplier
+ * @returns action
+ * @public
+ */
+export declare function updateLayerAnimationSpeed(speed: number): Merge<UpdateLayerAnimationSpeedUpdaterAction, {
+    type: typeof ActionTypes.UPDATE_LAYER_ANIMATION_SPEED;
+}>;
+export type ToggleLayerAnimationUpdaterAction = {};
+/**
+ * start end end layer animation
+ * @memberof visStateActions
+ * @returns action
+ * @public
+ */
+export declare function toggleLayerAnimation(): Merge<ToggleLayerAnimationUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_LAYER_ANIMATION;
+}>;
+export type ToggleLayerAnimationControlUpdaterAction = {};
+/**
+ * hide and show layer animation control
+ * @memberof visStateActions
+ * @returns action
+ * @public
+ */
+export declare function toggleLayerAnimationControl(): Merge<ToggleLayerAnimationControlUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_LAYER_ANIMATION_CONTROL;
+}>;
+export type EnlargeFilterUpdaterAction = {
+    idx: number;
+};
+/**
+ * Show larger time filter at bottom for time playback (apply to time filter only)
+ * @memberof visStateActions
+ * @param idx - index of filter to enlarge
+ * @returns action
+ * @public
+ */
+export declare function enlargeFilter(idx: number): Merge<EnlargeFilterUpdaterAction, {
+    type: typeof ActionTypes.ENLARGE_FILTER;
+}>;
+export type ToggleFilterFeatureUpdaterAction = {
+    idx: number;
+};
+/**
+ * Show/hide filter feature on map
+ * @memberof visStateActions
+ * @param idx - index of filter feature to show/hide
+ * @return action
+ */
+export declare function toggleFilterFeature(idx: number): Merge<ToggleFilterFeatureUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_FILTER_FEATURE;
+}>;
+export type OnLayerHoverUpdaterAction = {
+    info: {
+        picked?: boolean;
+    } | null;
+};
+/**
+ * Trigger layer hover event with hovered object
+ * @memberof visStateActions
+ * @param info - Object hovered, returned by deck.gl
+ * @returns action
+ * @public
+ */
+export declare function onLayerHover(info: {
+    picked?: boolean;
+} | null): Merge<OnLayerHoverUpdaterAction, {
+    type: typeof ActionTypes.LAYER_HOVER;
+}>;
+export type OnLayerClickUpdaterAction = {
+    info: {
+        picked?: boolean;
+    } | null;
+};
+/**
+ * Trigger layer click event with clicked object
+ * @memberof visStateActions
+ * @param info - Object clicked, returned by deck.gl
+ * @returns action
+ * @public
+ */
+export declare function onLayerClick(info: {
+    picked?: boolean;
+} | null): Merge<OnLayerClickUpdaterAction, {
+    type: typeof ActionTypes.LAYER_CLICK;
+}>;
+export type OnMapClickUpdaterAction = {};
+/**
+ * Trigger map click event, unselect clicked object
+ * @memberof visStateActions
+ * @returns action
+ * @public
+ */
+export declare function onMapClick(): Merge<OnMapClickUpdaterAction, {
+    type: typeof ActionTypes.MAP_CLICK;
+}>;
+export type OnMouseMoveUpdaterAction = {
+    evt: any;
+};
+/**
+ * Trigger map mouse moveevent, payload would be
+ * React-map-gl PointerEvent
+ * https://uber.github.io/react-map-gl/#/documentation/api-reference/pointer-event
+ *
+ * @memberof visStateActions
+ * @param evt - PointerEvent
+ * @returns action
+ * @public
+ */
+export declare function onMouseMove(evt: any): Merge<OnMouseMoveUpdaterAction, {
+    type: typeof ActionTypes.MOUSE_MOVE;
+}>;
+export type ToggleLayerForMapUpdaterAction = {
+    mapIndex: number;
+    layerId: string;
+};
+/**
+ * Toggle visibility of a layer in a split map
+ * @memberof visStateActions
+ * @param mapIndex - index of the split map
+ * @param layerId - id of the layer
+ * @returns action
+ * @public
+ */
+export declare function toggleLayerForMap(mapIndex: number, layerId: string): Merge<ToggleLayerForMapUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_LAYER_FOR_MAP;
+}>;
+export type SetFilterPlotUpdaterAction = {
+    idx: number;
+    newProp: object;
+    valueIndex?: number;
+};
+/**
+ * Set the property of a filter plot
+ * @memberof visStateActions
+ * @param idx
+ * @param newProp key value mapping of new prop `{yAxis: 'histogram'}`
+ * @param valueIndex dataId index
+ * @returns action
+ * @public
+ */
+export declare function setFilterPlot(idx: number, newProp: object, valueIndex?: number): Merge<SetFilterPlotUpdaterAction, {
+    type: typeof ActionTypes.SET_FILTER_PLOT;
+}>;
+export type SetMapInfoUpdaterAction = {
+    info: any;
+};
+/**
+ * Set the property of a filter plot
+ * @memberof visStateActions
+ * @param info
+ * @returns action
+ * @public
+ */
+export declare function setMapInfo(info: any): Merge<SetMapInfoUpdaterAction, {
+    type: typeof ActionTypes.SET_MAP_INFO;
+}>;
+export type LoadFilesUpdaterAction = {
+    files: File[];
+    onFinish?(result: any): any;
+};
+/**
+ * Trigger file loading dispatch `addDataToMap` if succeed, or `loadFilesErr` if failed
+ * @memberof visStateActions
+ * @param files array of fileblob
+ * @returns action
+ * @public
+ */
+export declare function loadFiles(files: File[], onFinish?: (result: any) => any): Merge<LoadFilesUpdaterAction, {
+    type: typeof ActionTypes.LOAD_FILES;
+}>;
+/**
+ * Called with next file to load
+ * @memberof visStateActions
+ * @returns action
+ * @public
+ */
+export declare function loadNextFile(): {
+    type: typeof ActionTypes.LOAD_NEXT_FILE;
+};
+export type loadFilesSuccessUpdaterAction = {
+    result: FileCacheItem[];
+};
+/**
+ * called when all files are processed and loaded
+ * @memberof visStateActions
+ * @param result
+ * @returns action
+ */
+export declare function loadFilesSuccess(result: FileCacheItem[]): Merge<loadFilesSuccessUpdaterAction, {
+    type: typeof ActionTypes.LOAD_FILES_SUCCESS;
+}>;
+export type LoadFileStepSuccessAction = {
+    fileName: string;
+    fileCache: FileCacheItem[];
+};
+/**
+ * called when successfully loaded one file, ready to move on to the next one
+ * @memberof visStateActions
+ * @param result
+ * @returns action
+ */
+export declare function loadFileStepSuccess({ fileName, fileCache }: {
+    fileName: string;
+    fileCache: FileCacheItem[];
+}): Merge<LoadFileStepSuccessAction, {
+    type: typeof ActionTypes.LOAD_FILE_STEP_SUCCESS;
+}>;
+export type LoadFilesErrUpdaterAction = {
+    fileName: string;
+    error: any;
+};
+/**
+ * Trigger loading file error
+ * @memberof visStateActions
+ * @param  error
+ * @returns action
+ * @public
+ */
+export declare function loadFilesErr(fileName: string, error: any): Merge<LoadFilesErrUpdaterAction, {
+    type: typeof ActionTypes.LOAD_FILES_ERR;
+}>;
+export type SetFeaturesUpdaterAction = {
+    features: Feature[];
+};
+/**
+ * Store features to state
+ * @memberof visStateActions
+ * @param features
+ * @returns action
+ */
+export declare function setFeatures(features: Feature[]): Merge<SetFeaturesUpdaterAction, {
+    type: typeof ActionTypes.SET_FEATURES;
+}>;
+export type SetPolygonFilterLayerUpdaterAction = {
+    layer: Layer;
+    feature: Feature;
+};
+/**
+ * It will apply the provide feature as filter to the given layer.
+ * If the given feature is already applied as filter to the layer, it will remove the layer from the filter
+ * @memberof visStateActions
+ * @param layer
+ * @param feature
+ * @returns action
+ */
+export declare function setPolygonFilterLayer(layer: Layer, feature: Feature): Merge<SetPolygonFilterLayerUpdaterAction, {
+    type: typeof ActionTypes.SET_POLYGON_FILTER_LAYER;
+}>;
+export type SetSelectedFeatureUpdaterAction = {
+    feature: Feature;
+};
+/**
+ * Set the current feature to be edited/deleted
+ * @memberof visStateActions
+ * @param feature
+ * @returns action
+ */
+export declare function setSelectedFeature(feature: Feature): Merge<SetSelectedFeatureUpdaterAction, {
+    type: typeof ActionTypes.SET_SELECTED_FEATURE;
+}>;
+export type DeleteFeatureUpdaterAction = {
+    feature: Feature;
+};
+/**
+ * Delete the given feature
+ * @memberof visStateActions
+ * @param feature
+ * @returns action
+ */
+export declare function deleteFeature(feature: Feature): Merge<DeleteFeatureUpdaterAction, {
+    type: typeof ActionTypes.DELETE_FEATURE;
+}>;
+export type SetEditorModeUpdaterAction = {
+    mode: string;
+};
+/** Set the map mode
+ * @memberof visStateActions
+ * @param mode one of EDITOR_MODES
+ * @returns action
+ * @public
+ * @example
+ * import {setMapMode} from 'kepler.gl/actions';
+ * import {EDITOR_MODES} from 'kepler.gl/constants';
+ *
+ * this.props.dispatch(setMapMode(EDITOR_MODES.DRAW_POLYGON));
+ */
+export declare function setEditorMode(mode: string): Merge<SetEditorModeUpdaterAction, {
+    type: typeof ActionTypes.SET_EDITOR_MODE;
+}>;
+export type ApplyCPUFilterUpdaterAction = {
+    dataId: string | string[];
+};
+/**
+ * Trigger CPU filter of selected dataset
+ * @memberof visStateActions
+ * @param dataId - single dataId or an array of dataIds
+ * @returns action
+ * @public
+ */
+export declare function applyCPUFilter(dataId: string | string[]): Merge<ApplyCPUFilterUpdaterAction, {
+    type: typeof ActionTypes.APPLY_CPU_FILTER;
+}>;
+export type ToggleEditorVisibilityUpdaterAction = {};
+/**
+ * Toggle editor layer visibility
+ * @memberof visStateActions
+ * @return action
+ */
+export declare function toggleEditorVisibility(): Merge<ToggleEditorVisibilityUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_EDITOR_VISIBILITY;
+}>;
+type FileContent = {
+    fileName: string;
+    header: string[];
+    data: any;
+};
+export type NextFileBatchUpdaterAction = {
+    payload: {
+        gen: AsyncGenerator<FileContent>;
+        fileName: string;
+        progress?: any;
+        accumulated?: any;
+        onFinish: (result: any) => any;
+    };
+};
+/**
+ * Process the next file batch
+ * @memberof visStateActions
+ * @param payload - batch payload
+ * @return action
+ */
+export declare function nextFileBatch(payload: NextFileBatchUpdaterAction['payload']): Merge<NextFileBatchUpdaterAction, {
+    type: typeof ActionTypes.NEXT_FILE_BATCH;
+}>;
+export type ProcessFileContentUpdaterAction = {
+    payload: {
+        content: FileContent;
+        fileCache: FileCacheItem[];
+    };
+};
+/**
+ * Process the file content
+ * @memberof visStateActions
+ * @param payload - the file content
+ * @return action
+ */
+export declare function processFileContent(payload: ProcessFileContentUpdaterAction['payload']): Merge<ProcessFileContentUpdaterAction, {
+    type: typeof ActionTypes.PROCESS_FILE_CONTENT;
+}>;
+export type SetLayerAnimationTimeConfigAction = {
+    config: {
+        timezone?: string;
+        timeFormat?: string;
+    };
+};
+/**
+ * Set layer animation time format and timezone
+ * @memberof visStateActions
+ * @param config - {timeFormat: string, timezone: string}
+ * @return action
+ */
+export declare function setLayerAnimationTimeConfig(config: SetLayerAnimationTimeConfigAction['config']): Merge<SetLayerAnimationTimeConfigAction, {
+    type: typeof ActionTypes.SET_LAYER_ANIMATION_TIME_CONFIG;
+}>;
+export type SetFilterAnimationTimeConfigAction = {
+    idx: number;
+    config: {
+        timezone?: string;
+        timeFormat?: string;
+    };
+};
+/**
+ * Set Filter animation time format and timezone
+ * @memberof visStateActions
+ * @param idx
+ * @param config
+ * @return action
+ */
+export declare function setFilterAnimationTimeConfig(idx: SetFilterAnimationTimeConfigAction['idx'], config: SetFilterAnimationTimeConfigAction['config']): Merge<SetFilterAnimationTimeConfigAction, {
+    type: typeof ActionTypes.SET_FILTER_ANIMATION_TIME_CONFIG;
+}>;
+export {};