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

package/dist/components/maps-layout.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+interface MapsLayoutFactoryProps {
+    className?: string;
+    children?: React.ReactNode;
+}
+declare function MapsLayoutFactory(): React.ComponentType<MapsLayoutFactoryProps>;
+declare namespace MapsLayoutFactory {
+    var deps: any[];
+}
+export default MapsLayoutFactory;

package/dist/components/modal-container.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+import ModalDialogFactory from './modals/modal-dialog';
+import DeleteDatasetModalFactory from './modals/delete-data-modal';
+import OverWriteMapModalFactory from './modals/overwrite-map-modal';
+import DataTableModalFactory from './modals/data-table-modal';
+import LoadDataModalFactory from './modals/load-data-modal';
+import ExportImageModalFactory from './modals/export-image-modal';
+import ExportDataModalFactory from './modals/export-data-modal';
+import ExportMapModalFactory from './modals/export-map-modal/export-map-modal';
+import AddMapStyleModalFactory from './modals/add-map-style-modal';
+import SaveMapModalFactory from './modals/save-map-modal';
+import ShareMapModalFactory from './modals/share-map-modal';
+import { MapState, MapStyle, UiState, VisState } from 'reducers';
+import { OnSuccessCallBack, OnErrorCallBack } from 'actions';
+import { ProviderState } from 'reducers/provider-state-updaters';
+import * as VisStateActions from 'actions/vis-state-actions';
+import * as UIStateActions from 'actions/ui-state-actions';
+import * as MapStyleActions from 'actions/map-style-actions';
+import * as ProviderActions from 'actions/provider-actions';
+import { Provider } from 'cloud-providers';
+export type ModalContainerProps = {
+    appName: string;
+    rootNode: React.ReactInstance | null | undefined;
+    containerW: number;
+    containerH: number;
+    mapboxApiUrl?: string;
+    mapState: MapState;
+    mapStyle: MapStyle;
+    uiState: UiState;
+    visState: VisState;
+    providerState: ProviderState;
+    visStateActions: typeof VisStateActions;
+    uiStateActions: typeof UIStateActions;
+    mapStyleActions: typeof MapStyleActions;
+    providerActions: typeof ProviderActions;
+    onSaveToStorage?: () => void;
+    cloudProviders: Provider[];
+    onLoadCloudMapSuccess?: OnSuccessCallBack;
+    onLoadCloudMapError?: OnErrorCallBack;
+    onExportToCloudSuccess?: OnSuccessCallBack;
+    onExportToCloudError?: OnErrorCallBack;
+};
+declare function ModalContainerFactory(DeleteDatasetModal: ReturnType<typeof DeleteDatasetModalFactory>, OverWriteMapModal: ReturnType<typeof OverWriteMapModalFactory>, DataTableModal: ReturnType<typeof DataTableModalFactory>, LoadDataModal: ReturnType<typeof LoadDataModalFactory>, ExportImageModal: ReturnType<typeof ExportImageModalFactory>, ExportDataModal: ReturnType<typeof ExportDataModalFactory>, ExportMapModal: ReturnType<typeof ExportMapModalFactory>, AddMapStyleModal: ReturnType<typeof AddMapStyleModalFactory>, ModalDialog: ReturnType<typeof ModalDialogFactory>, SaveMapModal: ReturnType<typeof SaveMapModalFactory>, ShareMapModal: ReturnType<typeof ShareMapModalFactory>): React.ElementType<ModalContainerProps>;
+declare namespace ModalContainerFactory {
+    var deps: ((() => React.FC<import("./modals/delete-data-modal").DeleteDatasetModalProps>) | (() => React.FC<{
+        mapSaved: string;
+        title: string;
+        cloudProviders: Provider[];
+        isProviderLoading: boolean;
+        currentProvider: string;
+        onUpdateImageSetting: (newSetting: Partial<import("reducers").ExportImage>) => void;
+        cleanupExportImage: () => {
+            type: "@@kepler.gl/CLEANUP_EXPORT_IMAGE";
+        };
+    }>) | typeof DataTableModalFactory | typeof LoadDataModalFactory | (() => React.ForwardRefExoticComponent<import("react-intl").Omit<import("./modals/export-image-modal").ExportImageModalProps, "intl"> & {
+        forwardedRef?: React.Ref<any>;
+    } & React.RefAttributes<any>> & {
+        WrappedComponent: React.ComponentType<import("./modals/export-image-modal").ExportImageModalProps>;
+    }) | (() => React.ForwardRefExoticComponent<import("react-intl").Omit<import("./modals/export-data-modal").ExportDataModalProps, "intl"> & {
+        forwardedRef?: React.Ref<any>;
+    } & React.RefAttributes<any>> & {
+        WrappedComponent: React.ComponentType<import("./modals/export-data-modal").ExportDataModalProps>;
+    }) | typeof ExportMapModalFactory | typeof AddMapStyleModalFactory | (() => import("styled-components").StyledComponent<typeof import("./common/modal").ModalDialog, any, {}, never>) | typeof SaveMapModalFactory | typeof ShareMapModalFactory)[];
+}
+export default ModalContainerFactory;

package/dist/components/modals/add-map-style-modal.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { IntlShape } from 'react-intl';
+import { InputStyle, MapState } from 'reducers';
+interface AddMapStyleModalProps {
+    inputMapStyle: Function;
+    inputStyle: InputStyle;
+    loadCustomMapStyle: Function;
+    mapboxApiUrl?: string;
+    mapState: MapState;
+    intl: IntlShape;
+}
+declare function AddMapStyleModalFactory(): React.ForwardRefExoticComponent<import("react-intl").Omit<AddMapStyleModalProps, "intl"> & {
+    forwardedRef?: React.Ref<any>;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<AddMapStyleModalProps>;
+};
+export default AddMapStyleModalFactory;

package/dist/components/modals/cloud-tile.d.ts

@@ -0,0 +1,15 @@
+import React, { ReactNode } from 'react';
+import { Provider } from 'cloud-providers';
+interface CloudTileProps {
+    onSelect?: React.MouseEventHandler<HTMLDivElement>;
+    onConnect?: React.MouseEventHandler<HTMLDivElement> | null;
+    onLogout?: React.MouseEventHandler<HTMLDivElement> | null;
+    actionName?: ReactNode | null;
+    cloudProvider: Provider;
+    onSetCloudProvider: any;
+    isSelected?: boolean;
+    isConnected?: boolean;
+    isReady?: boolean;
+}
+declare const CloudTile: React.FC<CloudTileProps>;
+export default CloudTile;

package/dist/components/modals/data-table-modal.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import DataTableFactory from 'components/common/data-table';
+import { Datasets } from 'reducers';
+import KeplerTable from 'utils/table-utils/kepler-table';
+interface DatasetModalTabProps {
+    active?: boolean;
+}
+export declare const DatasetModalTab: import("styled-components").StyledComponent<"div", any, DatasetModalTabProps, never>;
+interface DatasetTabsUnmemoizedProps {
+    activeDataset: KeplerTable;
+    datasets: Datasets;
+    showDatasetTable: (id: string) => void;
+}
+export declare const DatasetTabs: React.NamedExoticComponent<DatasetTabsUnmemoizedProps>;
+interface DataTableModalProps {
+    theme: any;
+    dataId?: string;
+    sortTableColumn: (id: string, column: string, mode?: string) => void;
+    pinTableColumn: (id: string, column: string) => void;
+    copyTableColumn: (id: string, column: string) => void;
+    datasets: Datasets;
+    showDatasetTable: (id: string) => void;
+    showTab?: boolean;
+}
+declare function DataTableModalFactory(DataTable: ReturnType<typeof DataTableFactory>): React.ComponentType<Omit<DataTableModalProps, "theme">>;
+declare namespace DataTableModalFactory {
+    var deps: (typeof DataTableFactory)[];
+}
+export default DataTableModalFactory;

package/dist/components/modals/delete-data-modal.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { Layer } from 'layers';
+import KeplerTable from 'utils/table-utils/kepler-table';
+export interface DeleteDatasetModalProps {
+    dataset: KeplerTable;
+    layers: Layer[];
+}
+export declare const DeleteDatasetModal: React.FC<DeleteDatasetModalProps>;
+declare const DeleteDatasetModalFactory: () => React.FC<DeleteDatasetModalProps>;
+export default DeleteDatasetModalFactory;

package/dist/components/modals/error-display.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+interface ErrorDisplayProps {
+    error: string;
+}
+declare const ErrorDisplay: React.FC<ErrorDisplayProps>;
+export default ErrorDisplay;

package/dist/components/modals/export-data-modal.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { IntlShape } from 'react-intl';
+import { Datasets } from 'reducers';
+export interface ExportDataModalProps {
+    datasets: Datasets;
+    selectedDataset?: string;
+    dataType: string;
+    filtered: boolean;
+    applyCPUFilter: (filter: string | string[]) => void;
+    onChangeExportSelectedDataset: (dataset: string) => void;
+    onChangeExportDataType: (type: string) => void;
+    onChangeExportFiltered: (isFiltered: boolean) => void;
+    intl: IntlShape;
+    supportedDataTypes: {
+        id: string;
+        label: string;
+        available: boolean;
+    }[];
+}
+declare const ExportDataModalFactory: () => React.ForwardRefExoticComponent<import("react-intl").Omit<ExportDataModalProps, "intl"> & {
+    forwardedRef?: React.Ref<any>;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<ExportDataModalProps>;
+};
+export default ExportDataModalFactory;

package/dist/components/modals/export-image-modal.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { SetExportImageSettingUpdaterAction } from '../../actions';
+import { IntlShape } from 'react-intl';
+import { ExportImage } from 'reducers';
+export interface ExportImageModalProps {
+    exportImage: ExportImage;
+    mapW: number;
+    mapH: number;
+    onUpdateImageSetting: (payload: SetExportImageSettingUpdaterAction['payload']) => void;
+    cleanupExportImage: () => void;
+    intl: IntlShape;
+}
+declare const ExportImageModalFactory: () => React.ForwardRefExoticComponent<import("react-intl").Omit<ExportImageModalProps, "intl"> & {
+    forwardedRef?: React.Ref<any>;
+} & React.RefAttributes<any>> & {
+    WrappedComponent: React.ComponentType<ExportImageModalProps>;
+};
+export default ExportImageModalFactory;

package/dist/components/modals/export-map-modal/components.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+export declare const StyledExportMapSection: import("styled-components").StyledComponent<"div", any, import("components/common/styled-components").StyledExportSectionProps, never>;
+export declare const StyledWarning: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const StyledExportLink: import("styled-components").StyledComponent<"a", any, {}, never>;
+export declare const ExportMapLink: ({ children, ...props }: {
+    [x: string]: any;
+    children: any;
+}) => React.JSX.Element;

package/dist/components/modals/export-map-modal/export-html-map.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { setUserMapboxAccessToken, setExportHTMLMapMode, ActionHandler } from 'actions';
+type ExportHtmlMapProps = {
+    onChangeExportMapHTMLMode: ActionHandler<typeof setExportHTMLMapMode>;
+    onEditUserMapboxAccessToken: ActionHandler<typeof setUserMapboxAccessToken>;
+    options: {
+        userMapboxToken?: string;
+        mode?: string;
+    };
+};
+declare function ExportHtmlMapFactory(): React.ComponentType<ExportHtmlMapProps>;
+export default ExportHtmlMapFactory;

package/dist/components/modals/export-map-modal/export-json-map.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+type ExportJsonPropTypes = {
+    config: any;
+};
+declare const ExportJsonMapFactory: () => React.MemoExoticComponent<{
+    ({ config }: ExportJsonPropTypes): React.JSX.Element;
+    displayName: string;
+}>;
+export default ExportJsonMapFactory;

package/dist/components/modals/export-map-modal/export-map-modal.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import ExportHtmlMapFactory from './export-html-map';
+import ExportJsonMapFactory from './export-json-map';
+import { ActionHandler, setExportHTMLMapMode, setUserMapboxAccessToken } from 'actions';
+interface ExportMapModalFactoryProps {
+    options?: {
+        format: string;
+    };
+    config: any;
+    onEditUserMapboxAccessToken: ActionHandler<typeof setUserMapboxAccessToken>;
+    onChangeExportMapHTMLMode?: ActionHandler<typeof setExportHTMLMapMode>;
+    onChangeExportMapFormat?: (format: string) => any;
+    mapFormat?: string;
+}
+declare function ExportMapModalFactory(ExportHtmlMap: ReturnType<typeof ExportHtmlMapFactory>, ExportJsonMap: ReturnType<typeof ExportJsonMapFactory>): React.MemoExoticComponent<{
+    ({ config, onChangeExportMapFormat, onChangeExportMapHTMLMode, onEditUserMapboxAccessToken, options }: ExportMapModalFactoryProps): React.JSX.Element;
+    displayName: string;
+}>;
+declare namespace ExportMapModalFactory {
+    var deps: (typeof ExportHtmlMapFactory | (() => React.MemoExoticComponent<{
+        ({ config }: {
+            config: any;
+        }): React.JSX.Element;
+        displayName: string;
+    }>))[];
+}
+export default ExportMapModalFactory;

package/dist/components/modals/image-modal-container.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { SetExportImageSettingUpdaterAction } from 'actions';
+import { Provider } from 'cloud-providers';
+/** @typedef {import('./image-modal-container').ImageModalContainerProps} ImageModalContainerProps */
+export type ImageModalContainerProps = {
+    children?: React.ReactNode;
+    cloudProviders?: Provider[];
+    currentProvider?: string | null;
+    onUpdateImageSetting: (newSetting: SetExportImageSettingUpdaterAction['payload']) => void;
+    cleanupExportImage: () => void;
+};
+/**
+ * A wrapper component in modals contain a image preview of the map with cloud providers
+ * It sets export image size based on provider thumbnail size
+ * @type {React.FunctionComponent<ImageModalContainerProps>}
+ */
+declare const ImageModalContainer: React.FC<ImageModalContainerProps>;
+export default ImageModalContainer;

package/dist/components/modals/load-data-modal.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+import { IntlShape } from 'react-intl';
+import FileUploadFactory from 'components/common/file-uploader/file-upload';
+import LoadStorageMapFactory from './load-storage-map';
+import ModalTabsFactory from './modal-tabs';
+import { FileLoading } from 'reducers/vis-state-updaters';
+export interface LoadingMethod {
+    id: string;
+    label: string;
+    elementType: React.ComponentType<any>;
+    tabElementType?: React.ComponentType<{
+        onClick: React.MouseEventHandler;
+        intl: IntlShape;
+    }>;
+}
+type LoadDataModalProps = {
+    onFileUpload: (files: File[]) => void;
+    onLoadCloudMap: (provider: any, vis: any) => void;
+    fileLoading: FileLoading | false;
+    loadingMethods: LoadingMethod[];
+    /** A list of names of supported formats suitable to present to user */
+    fileFormatNames: string[];
+    /** A list of typically 3 letter extensions (without '.') for file matching */
+    fileExtensions: string[];
+    isCloudMapLoading: boolean;
+    /** Set to true if app wants to do its own file filtering */
+    disableExtensionFilter?: boolean;
+};
+export declare function LoadDataModalFactory(ModalTabs: ReturnType<typeof ModalTabsFactory>, FileUpload: ReturnType<typeof FileUploadFactory>, LoadStorageMap: ReturnType<typeof LoadStorageMapFactory>): React.FC<LoadDataModalProps>;
+export declare namespace LoadDataModalFactory {
+    var deps: (typeof ModalTabsFactory | typeof FileUploadFactory | typeof LoadStorageMapFactory)[];
+}
+export default LoadDataModalFactory;

package/dist/components/modals/load-storage-map.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { MapListItem, Provider } from 'cloud-providers';
+interface Visualization extends MapListItem {
+    thumbnail?: Blob;
+}
+interface ProviderSelectProps {
+    cloudProviders: Provider[];
+    onSelect: (name: string) => void;
+    onSetCloudProvider: () => void;
+    currentProvider?: string;
+}
+export declare const ProviderSelect: React.FC<ProviderSelectProps>;
+interface LoadStorageMapProps {
+    cloudProviders: Provider[];
+    onSetCloudProvider: any;
+    currentProvider?: string;
+    getSavedMaps: (provider?: Provider) => void;
+    onLoadCloudMap: ({ loadParams, provider }: {
+        loadParams: any;
+        provider: Provider;
+    }) => void;
+    visualizations: Visualization[];
+    isProviderLoading?: boolean;
+}
+declare function LoadStorageMapFactory(): React.ComponentType<LoadStorageMapProps>;
+export default LoadStorageMapFactory;

package/dist/components/modals/loading-dialog.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface LoadingDialogProps {
+    size?: number;
+    message?: string;
+}
+declare const LoadingDialog: React.FC<LoadingDialogProps>;
+export default LoadingDialog;

package/dist/components/modals/modal-dialog.d.ts

@@ -0,0 +1,2 @@
+declare const ModalDialogFactory: () => import("styled-components").StyledComponent<typeof import("components/common/modal").ModalDialog, any, {}, never>;
+export default ModalDialogFactory;

package/dist/components/modals/modal-tabs.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { LoadingMethod } from './load-data-modal';
+interface ModalTabItemProps {
+    currentMethod?: string;
+    method: LoadingMethod;
+    toggleMethod: (method: LoadingMethod) => void;
+}
+export declare const ModalTabItem: React.FC<ModalTabItemProps>;
+declare function ModalTabsFactory(): {
+    ({ currentMethod, toggleMethod, loadingMethods }: {
+        currentMethod: any;
+        toggleMethod: any;
+        loadingMethods: any;
+    }): React.JSX.Element;
+    propTypes: {
+        toggleMethod: PropTypes.Validator<(...args: any[]) => any>;
+        currentMethod: PropTypes.Requireable<string>;
+        loadingMethods: PropTypes.Requireable<object[]>;
+    };
+    defaultProps: {
+        toggleMethod: () => void;
+        currentMethod: any;
+        loadingMethods: any[];
+    };
+};
+export default ModalTabsFactory;

package/dist/components/modals/overwrite-map-modal.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+import { Provider } from 'cloud-providers';
+import { ImageModalContainerProps } from './image-modal-container';
+import { cleanupExportImage } from 'actions';
+type OverwriteMapModalProps = {
+    mapSaved: string | null;
+    title: string;
+    cloudProviders: Provider[];
+    isProviderLoading: boolean;
+    currentProvider: string | null;
+    onUpdateImageSetting: ImageModalContainerProps['onUpdateImageSetting'];
+    cleanupExportImage: typeof cleanupExportImage;
+};
+declare const OverwriteMapModalFactory: () => React.FC<OverwriteMapModalProps>;
+export declare const OverwriteMapModal: React.FC<OverwriteMapModalProps>;
+export default OverwriteMapModalFactory;

package/dist/components/modals/provider-modal-container.d.ts

@@ -0,0 +1,23 @@
+import React, { Component } from 'react';
+import { Provider } from 'cloud-providers';
+import { SetCloudProviderPayload } from 'actions';
+export type ProviderModalContainerProps = {
+    children?: React.ReactNode;
+    cloudProviders?: Provider[];
+    currentProvider?: string | null;
+    onSetCloudProvider: (provider: SetCloudProviderPayload) => void;
+};
+/**
+ * A wrapper component in modals contain cloud providers.
+ * It set default provider by checking which provider has logged in
+ * @component
+ */
+export default class ProviderModalContainer extends Component<ProviderModalContainerProps> {
+    static defaultProps: {
+        cloudProviders: any[];
+        currentProvider: any;
+    };
+    componentDidMount(): void;
+    _setDefaultProvider(): void;
+    render(): React.JSX.Element;
+}

package/dist/components/modals/save-map-modal.d.ts

@@ -0,0 +1,29 @@
+import React from 'react';
+import { ImageModalContainerProps } from './image-modal-container';
+import { ProviderModalContainerProps } from './provider-modal-container';
+import { ExportImage, MapInfo } from 'reducers';
+import { Provider } from 'cloud-providers';
+import { setMapInfo, cleanupExportImage } from 'actions';
+type CharacterLimits = {
+    title?: number;
+    description?: number;
+};
+type SaveMapModalProps = {
+    mapInfo: MapInfo;
+    exportImage: ExportImage;
+    cloudProviders: Provider[];
+    isProviderLoading: boolean;
+    currentProvider?: string;
+    providerError?: any;
+    characterLimits?: CharacterLimits;
+    onSetCloudProvider: ProviderModalContainerProps['onSetCloudProvider'];
+    onUpdateImageSetting: ImageModalContainerProps['onUpdateImageSetting'];
+    cleanupExportImage: typeof cleanupExportImage;
+    onSetMapInfo: typeof setMapInfo;
+};
+type MapInfoPanelProps = Pick<SaveMapModalProps, 'mapInfo' | 'characterLimits'> & {
+    onChangeInput: (type: string, event: React.ChangeEvent<HTMLTextAreaElement | HTMLInputElement>) => void;
+};
+export declare const MapInfoPanel: React.FC<MapInfoPanelProps>;
+declare function SaveMapModalFactory(): React.FC<SaveMapModalProps>;
+export default SaveMapModalFactory;

package/dist/components/modals/share-map-modal.d.ts

@@ -0,0 +1,30 @@
+import React from 'react';
+import { ImageModalContainerProps } from './image-modal-container';
+import { Provider } from 'cloud-providers';
+import { cleanupExportImage, SetCloudProviderPayload } from 'actions';
+export declare const StyledInputLabel: import("styled-components").StyledComponent<"label", any, {}, never>;
+export declare const StyleSharingUrl: import("styled-components").StyledComponent<"div", any, {
+    className: "sharing-url";
+}, "className">;
+interface SharingUrlProps {
+    url: string;
+    message?: string;
+}
+export declare const SharingUrl: React.FC<SharingUrlProps>;
+interface ShareMapUrlModalFactoryProps {
+    isProviderLoading?: boolean;
+    isReady?: boolean;
+    onExport?: (provider: Provider) => void;
+    cloudProviders?: Provider[];
+    currentProvider: string | null;
+    providerError?: string;
+    successInfo?: {
+        shareUrl?: string;
+        folderLink?: string;
+    };
+    onSetCloudProvider?: (provider: SetCloudProviderPayload) => void;
+    onUpdateImageSetting: ImageModalContainerProps['onUpdateImageSetting'];
+    cleanupExportImage: typeof cleanupExportImage;
+}
+export default function ShareMapUrlModalFactory(): React.FC<ShareMapUrlModalFactoryProps>;
+export {};

package/dist/components/modals/status-panel.d.ts

@@ -0,0 +1,13 @@
+import React, { ComponentType } from 'react';
+import { IconProps } from 'cloud-providers/provider';
+interface UploadAnimationProps {
+    icon?: ComponentType<IconProps> | null;
+}
+export declare const UploadAnimation: React.FC<UploadAnimationProps>;
+interface StatusPanelProps {
+    error?: string | null;
+    isLoading?: boolean;
+    providerIcon?: ComponentType<IconProps> | null;
+}
+declare const StatusPanel: React.FC<StatusPanelProps>;
+export default StatusPanel;

package/dist/components/modals/storage-map-viewer.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+interface Asset {
+    imageUrl?: string;
+    label?: string;
+    title?: string;
+    description?: string;
+    lastUpdated?: number;
+    id?: string;
+}
+interface StorageAssetsViewerProps {
+    assets: Asset[];
+    onLoadAsset: (asset: Asset) => void;
+    back?: React.MouseEventHandler<HTMLDivElement>;
+    error?: {
+        message?: string;
+    };
+}
+declare class StorageAssetsViewer extends React.Component<StorageAssetsViewerProps> {
+    render(): React.JSX.Element;
+}
+export default StorageAssetsViewer;

package/dist/components/notification-panel/notification-item.d.ts

@@ -0,0 +1,66 @@
+import React from 'react';
+import { ActionHandler, removeNotification as removeNotificationActions } from 'actions';
+interface NotificationItemProps {
+    notification: {
+        id: string;
+        type: string;
+        message: string;
+    };
+    isExpanded?: boolean;
+    removeNotification?: ActionHandler<typeof removeNotificationActions>;
+    theme?: any;
+}
+export default function NotificationItemFactory(): {
+    new (props: NotificationItemProps): {
+        state: {
+            isExpanded: boolean;
+        };
+        componentDidMount(): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<NotificationItemProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<NotificationItemProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<NotificationItemProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<NotificationItemProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<NotificationItemProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<NotificationItemProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<NotificationItemProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<NotificationItemProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<NotificationItemProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    new (props: NotificationItemProps, context: any): {
+        state: {
+            isExpanded: boolean;
+        };
+        componentDidMount(): void;
+        render(): React.JSX.Element;
+        context: unknown;
+        setState<K extends never>(state: {} | ((prevState: Readonly<{}>, props: Readonly<NotificationItemProps>) => {} | Pick<{}, K>) | Pick<{}, K>, callback?: () => void): void;
+        forceUpdate(callback?: () => void): void;
+        readonly props: Readonly<NotificationItemProps>;
+        refs: {
+            [key: string]: React.ReactInstance;
+        };
+        shouldComponentUpdate?(nextProps: Readonly<NotificationItemProps>, nextState: Readonly<{}>, nextContext: any): boolean;
+        componentWillUnmount?(): void;
+        componentDidCatch?(error: Error, errorInfo: React.ErrorInfo): void;
+        getSnapshotBeforeUpdate?(prevProps: Readonly<NotificationItemProps>, prevState: Readonly<{}>): any;
+        componentDidUpdate?(prevProps: Readonly<NotificationItemProps>, prevState: Readonly<{}>, snapshot?: any): void;
+        componentWillMount?(): void;
+        UNSAFE_componentWillMount?(): void;
+        componentWillReceiveProps?(nextProps: Readonly<NotificationItemProps>, nextContext: any): void;
+        UNSAFE_componentWillReceiveProps?(nextProps: Readonly<NotificationItemProps>, nextContext: any): void;
+        componentWillUpdate?(nextProps: Readonly<NotificationItemProps>, nextState: Readonly<{}>, nextContext: any): void;
+        UNSAFE_componentWillUpdate?(nextProps: Readonly<NotificationItemProps>, nextState: Readonly<{}>, nextContext: any): void;
+    };
+    contextType?: React.Context<any>;
+};
+export {};