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

package/dist/actions/action-wrapper.d.ts

@@ -0,0 +1,115 @@
+/// <reference types="lodash" />
+export declare const FORWARD = "@redux-forward/FORWARD";
+export declare const ADDRESS_PREFIX = "@@KG_";
+export declare const getActionForwardAddress: (id: any) => string;
+/**
+ * Wrap an action into a forward action that only modify the state of a specific
+ * kepler.gl instance. kepler.gl reducer will look for signatures in the action to
+ * determine whether it needs to be forwarded to a specific instance reducer.
+ *
+ * wrapTo can be curried. You can create a curried action wrapper by only supply the `id` argument
+ *
+ * A forward action looks like this
+ * ```js
+ *  {
+ *    type: "@@kepler.gl/LAYER_CONFIG_CHANGE",
+ *    payload: {
+ *      type: '@@kepler.gl/LAYER_CONFIG_CHANGE',
+ *      payload: {},
+ *      meta: {
+ *       // id of instance
+ *        _id_: id
+ *       // other meta
+ *      }
+ *    },
+ *    meta: {
+ *      _forward_: '@redux-forward/FORWARD',
+ *      _addr_: '@@KG_id'
+ *    }
+ *  };
+ * ```
+ *
+ * @memberof forwardActions
+ * @param {string} id - The id to forward to
+ * @param {Object} action - the action object {type: string, payload: *}
+ * @returns {{type: string, payload: {type: string, payload: *, meta: {_id_: string}, meta: {_forward_: string, _addr_: string}}}}
+ * @public
+ * @example
+ *
+ * import {wrapTo, togglePerspective} from 'kepler.gl/actions';
+ *
+ * // This action will only dispatch to the KeplerGl instance with `id: map_1`
+ * this.props.dispatch(wrapTo('map_1', togglePerspective()));
+ *
+ * // You can also create a curried action for each instance
+ * const wrapToMap1 = wrapTo('map_1');
+ * this.props.dispatch(wrapToMap1(togglePerspective()));
+ */
+export declare const wrapTo: import("lodash").CurriedFunction2<any, any, {
+    type: any;
+    payload: any;
+    meta: any;
+}>;
+/**
+ * Whether an action is a forward action
+ * @memberof forwardActions
+ * @param {Object} action - the action object
+ * @returns {boolean} boolean - whether the action is a forward action
+ * @public
+ */
+export declare const isForwardAction: (action: any) => boolean;
+/**
+ * Unwrap an action
+ * @memberof forwardActions
+ * @param {Object} action - the action object
+ * @returns {Object} - unwrapped action
+ * @public
+ */
+export declare const unwrap: (action: any) => any;
+/**
+ * Given an id, returns the action for that id.
+ * If the action is not a forward action, return the action
+ * @memberof forwardActions
+ * @param {String} id
+ * @param {Object} action
+ * @private
+ */
+export declare const _actionFor: (id: any, action: any) => any;
+/**
+ * Returns an action dispatcher that wraps and forwards the actions to a specific instance
+ * @memberof forwardActions
+ * @param {string} id - instance id
+ * @param {Function} dispatch - action dispatcher
+ * @public
+ * @example
+ *
+ * // action and forward dispatcher
+ * import {toggleSplitMap, forwardTo} from 'kepler.gl/actions';
+ * import {connect} from 'react-redux';
+ *
+ * const MapContainer = props => (
+ *  <div>
+ *   <button onClick={() => props.keplerGlDispatch(toggleSplitMap())}/>
+ *  </div>
+ * )
+ *
+ * const mapDispatchToProps = (dispatch, props) => ({
+ *  dispatch,
+ *  keplerGlDispatch: forwardTo(‘foo’, dispatch)
+ * });
+ *
+ * export default connect(
+ *  state => state,
+ *  mapDispatchToProps
+ * )(MapContainer);
+ */
+export declare const forwardTo: (id: any, dispatch: any) => (action: any) => any;
+/**
+ * Update the state of a kepler.gl instance
+ * @memberof forwardActions
+ * @param {Object} state
+ * @param {string} id
+ * @param {Object} nextState
+ * @private
+ */
+export declare const _updateProperty: (state: any, id: any, nextState: any) => any;

package/dist/actions/actions.d.ts

@@ -0,0 +1,195 @@
+import ActionTypes from 'constants/action-types';
+import { ParsedConfig } from '../schemas';
+import { RGBColor } from 'reducers/types';
+import { Bounds } from 'reducers/map-state-updaters';
+import { MapInfo } from 'reducers/vis-state-updaters';
+import { UiState } from 'reducers/ui-state-updaters';
+/**
+ * Input dataest parsed to addDataToMap
+ */
+export type ProtoDataset = {
+    info: {
+        id?: string;
+        label?: string;
+        format?: string;
+        color?: RGBColor;
+    };
+    data: {
+        fields: {
+            name: string;
+            type?: string;
+            format?: string;
+            displayName?: string;
+            id?: string;
+        }[];
+        rows: any[][];
+    };
+    metadata?: any;
+    supportedFilterTypes?: string[];
+};
+export type AddDataToMapOptions = {
+    centerMap?: boolean;
+    readOnly?: boolean;
+    keepExistingConfig?: boolean;
+    autoCreateLayers?: boolean;
+};
+export type AddDataToMapPayload = {
+    datasets: ProtoDataset[] | ProtoDataset;
+    options?: AddDataToMapOptions;
+    config?: ParsedConfig;
+    info?: Partial<MapInfo>;
+};
+export type ActionHandler<A extends (...args: any) => any> = (...args: Parameters<A>) => void;
+/**
+ * Add data to kepler.gl reducer, prepare map with preset configuration if config is passed.
+ * Kepler.gl provides a handy set of utils to parse data from different formats to the `data` object required in dataset. You rarely need to manually format the data obejct.
+ *
+ * Use `KeplerGlSchema.getConfigToSave` to generate a json blob of the currents instance config.
+ * The config object value will always have higher precedence than the options properties.
+ *
+ * Kepler.gl uses `dataId` in the config to match with loaded dataset. If you pass a config object, you need
+ * to match the `info.id` of your dataset to the `dataId` in each `layer`, `filter` and `interactionConfig.tooltips.fieldsToShow`
+ *
+ * @memberof main
+ * @param {Object} data
+ * @param {Array<Object>|Object} data.datasets - ***required** datasets can be a dataset or an array of datasets
+ * Each dataset object needs to have `info` and `data` property.
+ * @param {Object} data.datasets.info -info of a dataset
+ * @param {string} data.datasets.info.id - id of this dataset. If config is defined, `id` should matches the `dataId` in config.
+ * @param {string} data.datasets.info.label - A display name of this dataset
+ * @param {Object} data.datasets.data - ***required** The data object, in a tabular format with 2 properties `fields` and `rows`
+ * @param {Array<Object>} data.datasets.data.fields - ***required** Array of fields,
+ * @param {string} data.datasets.data.fields.name - ***required** Name of the field,
+ * @param {Array<Array>} data.datasets.data.rows - ***required** Array of rows, in a tabular format with `fields` and `rows`
+ *
+ * @param {Object} data.options
+ * @param {boolean} data.options.centerMap `default: true` if `centerMap` is set to `true` kepler.gl will
+ * place the map view within the data points boundaries.  `options.centerMap` will override `config.mapState` if passed in.
+ * @param {boolean} data.options.readOnly `default: false` if `readOnly` is set to `true`
+ * the left setting panel will be hidden
+ * @param {boolean} data.options.keepExistingConfig whether to keep exiting map data and associated layer filter  interaction config `default: false`.
+ * @param {Object} data.config this object will contain the full kepler.gl instance configuration {mapState, mapStyle, visState}
+ * @public
+ * @example
+ *
+ * // app.js
+ * import {addDataToMap} from 'kepler.gl/actions';
+ *
+ * const sampleTripData = {
+ *  fields: [
+ *    {name: 'tpep_pickup_datetime', format: 'YYYY-M-D H:m:s', type: 'timestamp'},
+ *    {name: 'pickup_longitude', format: '', type: 'real'},
+ *    {name: 'pickup_latitude', format: '', type: 'real'}
+ *  ],
+ *  rows: [
+ *    ['2015-01-15 19:05:39 +00:00', -73.99389648, 40.75011063],
+ *    ['2015-01-15 19:05:39 +00:00', -73.97642517, 40.73981094],
+ *    ['2015-01-15 19:05:40 +00:00', -73.96870422, 40.75424576],
+ *  ]
+ * };
+ *
+ * const sampleConfig = {
+ *   visState: {
+ *     filters: [
+ *       {
+ *         id: 'me',
+ *         dataId: 'test_trip_data',
+ *         name: 'tpep_pickup_datetime',
+ *         type: 'timeRange',
+ *         enlarged: true
+ *       }
+ *     ]
+ *   }
+ * }
+ *
+ * this.props.dispatch(
+ *   addDataToMap({
+ *     datasets: {
+ *       info: {
+ *         label: 'Sample Taxi Trips in New York City',
+ *         id: 'test_trip_data'
+ *       },
+ *       data: sampleTripData
+ *     },
+ *     options: {
+ *       centerMap: true,
+ *       readOnly: false,
+ *       keepExistingConfig: false
+ *     },
+ *     info: {
+ *       title: 'Taro and Blue',
+ *       description: 'This is my map'
+ *     },
+ *     config: sampleConfig
+ *   })
+ * );
+ */
+export declare const addDataToMap: (data: AddDataToMapPayload) => {
+    type: typeof ActionTypes.ADD_DATA_TO_MAP;
+    payload: AddDataToMapPayload;
+};
+/**
+ * Reset all sub-reducers to its initial state. This can be used to clear out all configuration in the reducer.
+ * @memberof main
+ * @public
+ */
+export declare const resetMapConfig: () => {
+    type: typeof ActionTypes.RESET_MAP_CONFIG;
+};
+export type ReceiveMapConfigPayload = {
+    config: ParsedConfig;
+    options?: AddDataToMapOptions;
+    bounds?: Bounds;
+};
+/**
+ * Pass config to kepler.gl instance, prepare the state with preset configs.
+ * Calling `KeplerGlSchema.parseSavedConfig` to convert saved config before passing it in is required.
+ *
+ * You can call `receiveMapConfig` before passing in any data. The reducer will store layer and filter config, waiting for
+ * data to come in. When data arrives, you can call `addDataToMap` without passing any config, and the reducer will try to match
+ * preloaded configs. This behavior is designed to allow asynchronous data loading.
+ *
+ * It is also useful when you want to prepare the kepler.gl instance with some preset layer and filter settings.
+ * **Note** Sequence is important, `receiveMapConfig` needs to be called __before__ data is loaded. Currently kepler.gl doesn't allow calling `receiveMapConfig` after data is loaded.
+ * It will reset current configuration first then apply config to it.
+ * @memberof main
+ * @param {Object} config - ***required** The Config Object
+ * @param {Object} options - ***optional** The Option object
+ * @param {boolean} options.centerMap `default: true` if `centerMap` is set to `true` kepler.gl will
+ * place the map view within the data points boundaries
+ * @param {boolean} options.readOnly `default: false` if `readOnly` is set to `true`
+ * the left setting panel will be hidden
+ * @param {boolean} options.keepExistingConfig whether to keep exiting layer filter and interaction config `default: false`.
+ * @param {boolean} options.autoCreateLayers whether to automatically create layers based on dataset columns `default: true`.
+ * @public
+ * @example
+ * import {receiveMapConfig} from 'kepler.gl/actions';
+ * import KeplerGlSchema from 'kepler.gl/schemas';
+ *
+ * const parsedConfig = KeplerGlSchema.parseSavedConfig(config);
+ * this.props.dispatch(receiveMapConfig(parsedConfig));
+ */
+export declare const receiveMapConfig: (config: ReceiveMapConfigPayload['config'], options: ReceiveMapConfigPayload['options']) => {
+    type: typeof ActionTypes.RECEIVE_MAP_CONFIG;
+    payload: ReceiveMapConfigPayload;
+};
+export type KeplerGlInitPayload = {
+    mapboxApiAccessToken?: string;
+    mapboxApiUrl?: string;
+    mapStylesReplaceDefault?: boolean;
+    initialUiState?: Partial<UiState>;
+};
+/**
+ * Initialize kepler.gl reducer. It is used to pass in `mapboxApiAccessToken` to `mapStyle` reducer.
+ * @memberof main
+ * @param {object} payload
+ * @param payload.mapboxApiAccessToken - mapboxApiAccessToken to be saved to mapStyle reducer
+ * @param payload.mapboxApiUrl - mapboxApiUrl to be saved to mapStyle reducer.
+ * @param payload.mapStylesReplaceDefault - mapStylesReplaceDefault to be saved to mapStyle reducer
+ * @param payload.initialUiState - initial ui state
+ * @public
+ */
+export declare const keplerGlInit: (options?: KeplerGlInitPayload) => {
+    type: typeof ActionTypes.INIT;
+    payload: KeplerGlInitPayload;
+};

package/dist/actions/identity-actions.d.ts

@@ -0,0 +1,61 @@
+import ActionTypes from 'constants/action-types';
+import { UiState } from 'reducers/ui-state-updaters';
+export type RegisterEntryUpdaterAction = {
+    payload: {
+        id: string;
+        mint?: boolean;
+        mapboxApiAccessToken?: string;
+        mapboxApiUrl?: string;
+        mapStylesReplaceDefault?: boolean;
+        initialUiState?: Partial<UiState>;
+    };
+};
+/**
+ *
+ * Add a new kepler.gl instance in `keplerGlReducer`. This action is called under-the-hood when a `KeplerGl` component is **mounted** to the dom.
+ * Note that if you dispatch actions such as adding data to a kepler.gl instance before the React component is mounted, the action will not be
+ * performed. Instance reducer can only handle actions when it is instantiated.
+ * @memberof rootActions
+ * @param payload
+ * @param payload.id - ***required** The id of the instance
+ * @param payload.mint - Whether to use a fresh empty state, when `mint: true` it will *always* load a fresh state when the component is re-mounted.
+ * When `mint: false` it will register with existing instance state under the same `id`, when the component is unmounted then mounted again. Default: `true`
+ * @param payload.mapboxApiAccessToken - mapboxApiAccessToken to be saved in `map-style` reducer.
+ * @param payload.mapboxApiUrl - mapboxApiUrl to be saved in `map-style` reducer.
+ * @param payload.mapStylesReplaceDefault - mapStylesReplaceDefault to be saved in `map-style` reducer.
+ * @param payload.initialUiState - initial ui state
+ * @public
+ */
+export declare const registerEntry: (entry: RegisterEntryUpdaterAction['payload']) => {
+    type: typeof ActionTypes.REGISTER_ENTRY;
+    payload: RegisterEntryUpdaterAction['payload'];
+};
+/**
+ *
+ * Delete an instance from `keplerGlReducer`. This action is called under-the-hood when a `KeplerGl` component is **un-mounted** to the dom.
+ * If `mint` is set to be `true` in the component prop, the instance state will be deleted from the root reducer. Otherwise, the root reducer will keep
+ * the instance state and later transfer it to a newly mounted component with the same `id`
+ * @memberof rootActions
+ * @param {string} id - the id of the instance to be deleted
+ * @public
+ */
+export declare const deleteEntry: (id: string) => {
+    type: typeof ActionTypes.DELETE_ENTRY;
+    payload: string;
+};
+/**
+ *
+ * Rename an instance in the root reducer, keep its entire state
+ *
+ * @memberof rootActions
+ * @param {string} oldId - ***required** old id
+ * @param {string} newId - ***required** new id
+ * @public
+ */
+export declare const renameEntry: (oldId: string, newId: string) => {
+    type: typeof ActionTypes.RENAME_ENTRY;
+    payload: {
+        oldId: string;
+        newId: string;
+    };
+};

package/dist/actions/index.d.ts

@@ -0,0 +1,9 @@
+export * from './actions';
+export * from './vis-state-actions';
+export * from './ui-state-actions';
+export * from './map-state-actions';
+export * from './map-style-actions';
+export * from './identity-actions';
+export * from './provider-actions';
+export { _actionFor, forwardTo, getActionForwardAddress, isForwardAction, unwrap, wrapTo } from './action-wrapper';
+export { default as ActionTypes } from '../constants/action-types';

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

@@ -0,0 +1,69 @@
+import ActionTypes from 'constants/action-types';
+import { Merge } from '../reducers/types';
+import { Bounds, Viewport } from '../reducers/map-state-updaters';
+export type TogglePerspectiveUpdaterAction = {};
+/**
+ *
+ * Toggle between 3d and 2d map.
+ * @memberof mapStateActions
+ * @public
+ * @example
+ * import {togglePerspective} from 'kepler.gl/actions';
+ * this.props.dispatch(togglePerspective());
+ */
+export declare const togglePerspective: () => Merge<TogglePerspectiveUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_PERSPECTIVE;
+}>;
+export type FitBoundsUpdaterAction = {
+    payload: Bounds;
+};
+/**
+ * Fit map viewport to bounds
+ * @memberof mapStateActions
+ * @param {Array<Number>} bounds as `[lngMin, latMin, lngMax, latMax]`
+ * @public
+ * @example
+ * import {fitBounds} from 'kepler.gl/actions';
+ * this.props.dispatch(fitBounds([-122.23, 37.127, -122.11, 37.456]));
+ */
+export declare const fitBounds: (payload: Bounds) => Merge<FitBoundsUpdaterAction, {
+    type: typeof ActionTypes.FIT_BOUNDS;
+}>;
+export type UpdateMapUpdaterAction = {
+    payload: Viewport;
+};
+/**
+ * Update map viewport
+ * @memberof mapStateActions
+ * @param {Object} viewport viewport object container one or any of these properties `width`, `height`, `latitude` `longitude`, `zoom`, `pitch`, `bearing`, `dragRotate`
+ * @param {Number} [viewport.width] Width of viewport
+ * @param {Number} [viewport.height] Height of viewport
+ * @param {Number} [viewport.zoom] Zoom of viewport
+ * @param {Number} [viewport.pitch] Camera angle in degrees (0 is straight down)
+ * @param {Number} [viewport.bearing] Map rotation in degrees (0 means north is up)
+ * @param {Number} [viewport.latitude] Latitude center of viewport on map in mercator projection
+ * @param {Number} [viewport.longitude] Longitude Center of viewport on map in mercator projection
+ * @param {boolean} [viewport.dragRotate] Whether to enable drag and rotate map into perspective viewport
+ * @public
+ * @example
+ * import {updateMap} from 'kepler.gl/actions';
+ * this.props.dispatch(updateMap({latitude: 37.75043, longitude: -122.34679, width: 800, height: 1200}));
+ */
+export declare const updateMap: (payload: Viewport) => Merge<UpdateMapUpdaterAction, {
+    type: typeof ActionTypes.UPDATE_MAP;
+}>;
+export type ToggleSplitMapUpdaterAction = {
+    payload: number;
+};
+/**
+ * Toggle between single map or split maps
+ * @memberof mapStateActions
+ * @param {Number} [index] index is provided, close split map at index
+ * @public
+ * @example
+ * import {toggleSplitMap} from 'kepler.gl/actions';
+ * this.props.dispatch(toggleSplitMap());
+ */
+export declare const toggleSplitMap: (payload: number) => Merge<ToggleSplitMapUpdaterAction, {
+    type: typeof ActionTypes.TOGGLE_SPLIT_MAP;
+}>;

package/dist/actions/map-style-actions.d.ts

@@ -0,0 +1,146 @@
+import ActionTypes from 'constants/action-types';
+import { Merge, RGBColor } from '../reducers/types';
+import { InputStyle, MapStyles, VisibleLayerGroups } from '../reducers/map-style-updaters';
+import { MapState } from '../reducers/map-state-updaters';
+/**
+ * Add map style from user input to reducer and set it to current style
+ * This action is called when user click confirm after putting in a valid style url in the custom map style dialog.
+ * It should not be called from outside kepler.gl without a valid `inputStyle` in the `mapStyle` reducer.
+ * param {void}
+ * @memberof mapStyleActions
+ * @public
+ */
+export declare const addCustomMapStyle: () => {
+    type: typeof ActionTypes.ADD_CUSTOM_MAP_STYLE;
+};
+/** INPUT_MAP_STYLE */
+export type InputMapStyleUpdaterAction = {
+    payload: {
+        inputStyle: Partial<InputStyle>;
+        mapState?: MapState;
+    };
+};
+/**
+ * Input a custom map style object
+ * @memberof mapStyleActions
+ * @param inputStyle
+ * @param inputStyle.url - style url e.g. `'mapbox://styles/heshan/xxxxxyyyyzzz'`
+ * @param inputStyle.id - style id e.g. `'custom_style_1'`
+ * @param inputStyle.style - actual mapbox style json
+ * @param inputStyle.label - style name
+ * @param inputStyle.accessToken - mapbox access token
+ * @param inputStyle.icon - icon image data url
+ * @param [mapState] - mapState is optional
+ * @public
+ */
+export declare const inputMapStyle: (inputStyle: InputMapStyleUpdaterAction['payload']['inputStyle'], mapState?: InputMapStyleUpdaterAction['payload']['mapState']) => Merge<InputMapStyleUpdaterAction, {
+    type: typeof ActionTypes.INPUT_MAP_STYLE;
+}>;
+/** MAP_CONFIG_CHANGE */
+export type MapConfigChangeUpdaterAction = {
+    payload: {
+        visibleLayerGroups?: VisibleLayerGroups;
+        topLayerGroups?: VisibleLayerGroups;
+    };
+};
+/**
+ * Update `visibleLayerGroups`to change layer group visibility
+ * @memberof mapStyleActions
+ * @param mapStyle new config `{visibleLayerGroups: {label: false, road: true, background: true}}`
+ * @public
+ */
+export declare const mapConfigChange: (mapStyle: MapConfigChangeUpdaterAction['payload']) => Merge<MapConfigChangeUpdaterAction, {
+    type: typeof ActionTypes.MAP_CONFIG_CHANGE;
+}>;
+/** REQUEST_MAP_STYLES */
+export type RequestMapStylesUpdaterAction = {
+    payload: {
+        [key: string]: {
+            id: string;
+            label?: string;
+            url: string;
+            icon?: string;
+            layerGroups?: string;
+        };
+    };
+};
+/**
+ * Request map style style object based on style.url.
+ * @memberof mapStyleActions
+ * @public
+ */
+export declare const requestMapStyles: (mapStyles: RequestMapStylesUpdaterAction['payload']) => Merge<RequestMapStylesUpdaterAction, {
+    type: typeof ActionTypes.REQUEST_MAP_STYLES;
+}>;
+/** LOAD_MAP_STYLES */
+export type LoadMapStylesUpdaterAction = {
+    payload: MapStyles;
+};
+/**
+ * Callback when load map style success
+ * @memberof mapStyleActions
+ * @param newStyles a `{[id]: style}` mapping
+ * @public
+ */
+export declare const loadMapStyles: (newStyles: LoadMapStylesUpdaterAction['payload']) => Merge<LoadMapStylesUpdaterAction, {
+    type: typeof ActionTypes.LOAD_MAP_STYLES;
+}>;
+/** LOAD_MAP_STYLE_ERR */
+export type LoadMapStyleErrUpdaterAction = {
+    payload: Error;
+};
+/**
+ * Callback when load map style error
+ * @memberof mapStyleActions
+ * @param error
+ * @public
+ */
+export declare const loadMapStyleErr: (error: LoadMapStyleErrUpdaterAction['payload']) => Merge<LoadMapStyleErrUpdaterAction, {
+    type: typeof ActionTypes.LOAD_MAP_STYLE_ERR;
+}>;
+/** MAP_STYLE_CHANGE */
+export type MapStyleChangeUpdaterAction = {
+    payload: string;
+};
+/**
+ * Change to another map style. The selected style should already been loaded into `mapStyle.mapStyles`
+ * @memberof mapStyleActions
+ * @param styleType the style to change to
+ * @public
+ */
+export declare const mapStyleChange: (styleType: MapStyleChangeUpdaterAction['payload']) => Merge<MapStyleChangeUpdaterAction, {
+    type: typeof ActionTypes.MAP_STYLE_CHANGE;
+}>;
+/** LOAD_CUSTOM_MAP_STYLE */
+export type LoadCustomMapStyleUpdaterAction = {
+    payload: {
+        icon?: string;
+        style?: object;
+        error?: Error;
+    };
+};
+/**
+ * Callback when a custom map style object is received
+ * @memberof mapStyleActions
+ * @param customMapStyle
+ * @param customMapStyle.icon
+ * @param customMapStyle.style
+ * @param customMapStyle.error
+ * @public
+ */
+export declare const loadCustomMapStyle: (customMapStyle: LoadCustomMapStyleUpdaterAction['payload']) => Merge<LoadCustomMapStyleUpdaterAction, {
+    type: typeof ActionTypes.LOAD_CUSTOM_MAP_STYLE;
+}>;
+/** SET_3D_BUILDING_COLOR */
+export type Set3dBuildingColorUpdaterAction = {
+    payload: RGBColor;
+};
+/**
+ * Set 3d building layer group color
+ * @memberof mapStyleActions
+ * @param color - [r, g, b]
+ * @public
+ */
+export declare const set3dBuildingColor: (color: Set3dBuildingColorUpdaterAction['payload']) => Merge<Set3dBuildingColorUpdaterAction, {
+    type: typeof ActionTypes.SET_3D_BUILDING_COLOR;
+}>;