import { FeatureCollection } from 'geojson';
import { JSX } from 'react';
import { ReactElement } from 'react';

declare interface AdvancedDataSelectionDataType {
    label?: string;
    options: {
        label: string;
        dataConfiguration: {
            columnId: string[] | string;
            chartConfigId: string;
        }[];
        graphSettings?: GraphSettingsDataType;
    }[];
    ui?: 'select' | 'radio';
    width?: string;
    defaultValue?: {
        label: string;
        dataConfiguration: {
            columnId: string[] | string;
            chartConfigId: string;
        }[];
        graphSettings?: GraphSettingsDataType;
    };
}

declare interface AggregationSettingsDataType {
    column: string;
    aggregationMethod?: 'sum' | 'average' | 'min' | 'max';
}

declare interface AmbientLightConfig extends BaseLightConfig {
    type: 'ambient';
}

declare interface AnimateDataType {
    duration: number;
    once: boolean;
    amount: 'some' | 'all' | number;
}

declare interface AnnotationSettingsDataType {
    text: string;
    maxWidth?: number;
    xCoordinate?: number | string;
    yCoordinate?: number | string;
    xOffset?: number;
    yOffset?: number;
    align?: 'center' | 'left' | 'right';
    color?: string;
    fontWeight?: 'regular' | 'bold' | 'medium';
    showConnector?: boolean | number;
    connectorRadius?: number;
    classNames?: {
        connector?: string;
        text?: string;
    };
    styles?: {
        connector?: React.CSSProperties;
        text?: React.CSSProperties;
    };
}

declare interface AxesClassNameObject {
    gridLines?: string;
    labels?: string;
    title?: string;
    axis?: string;
}

declare interface AxesStyleObject {
    gridLines?: React.CSSProperties;
    labels?: React.CSSProperties;
    title?: React.CSSProperties;
    axis?: React.CSSProperties;
}

declare interface BaseLightConfig {
    type: string;
    color: number;
    intensity: number;
}

declare interface ClassNameObject {
    title?: string;
    footnote?: string;
    source?: string;
    description?: string;
    tooltip?: string;
    xAxis?: AxesClassNameObject;
    yAxis?: AxesClassNameObject;
    legend?: string;
    graphContainer?: string;
    graphObjectValues?: string;
    dataConnectors?: string;
    mouseOverLine?: string;
    regLine?: string;
    dataCards?: string;
    colorLegend?: string;
    modal?: string;
    area?: string;
}

declare type Color = 'azure' | 'blue' | 'green' | 'lime' | 'orange' | 'pink' | 'red' | 'teal' | 'violet' | 'yellow' | 'primary' | 'secondary' | 'tertiary' | 'quaternary' | 'background' | 'surface' | 'surface-2xs' | 'surface-xs' | 'surface-sm' | 'surface-md' | 'surface-lg' | 'surface-xl' | 'surface-2xl' | 'surface-3xl' | 'surface-4xl' | 'foreground' | 'sdg-1' | 'sdg-2' | 'sdg-3' | 'sdg-4' | 'sdg-5' | 'sdg-6' | 'sdg-7' | 'sdg-8' | 'sdg-9' | 'sdg-10' | 'sdg-11' | 'sdg-12' | 'sdg-13' | 'sdg-14' | 'sdg-15' | 'sdg-16' | 'sdg-17' | 'male' | 'female' | 'urban' | 'rural' | 'child' | 'adolescent' | 'young-adult' | 'adult' | 'older-adult';

declare interface ColumnConfigurationDataType {
    column: string;
    delimiter?: string;
}

declare interface ConfigObject {
    graphSettings?: GraphSettingsDataType;
    dataSettings: DataSettingsDataType;
    filters?: FilterUiSettingsDataType[];
    graphType: ThreeDGraphType;
    noOfFiltersPerRow?: number;
    dataTransform?: {
        keyColumn: string;
        aggregationColumnsSetting?: AggregationSettingsDataType[];
    };
    dataFilters?: DataFilterDataType[];
    graphDataConfiguration?: GraphConfigurationDataType[];
    debugMode?: boolean;
    dataSelectionOptions?: DataSelectionDataType[];
    advancedDataSelectionOptions?: AdvancedDataSelectionDataType[];
    highlightDataPointSettings?: HighlightDataPointSettingsDataType;
    readableHeader?: {
        value: string;
        label: string;
    }[];
    uiMode?: 'light' | 'normal';
}

declare type CurveTypes = 'linear' | 'curve' | 'step' | 'stepAfter' | 'stepBefore';

declare interface CustomHighlightAreaSettingsDataType {
    coordinates: (number | string)[];
    closePath?: boolean;
    style?: React.CSSProperties;
    className?: string;
    color?: string;
    strokeWidth?: number;
}

declare interface CustomLayerDataType {
    position: 'before' | 'after';
    layer: React.ReactNode;
}

declare interface DataFilterDataType {
    column: string;
    includeValues?: (string | number | boolean | null | undefined)[];
    excludeValues?: (string | number | boolean | null | undefined)[];
}

declare interface DataSelectionDataType {
    label?: string;
    allowedColumnIds: {
        value: string;
        label: string;
        graphSettings: GraphSettingsDataType;
    }[];
    chartConfigId: string;
    ui?: 'select' | 'radio';
    width?: string;
}

declare interface DataSettingsDataType {
    dataURL?: string | FileSettingsDataType[];
    fileType?: 'csv' | 'json' | 'api';
    delimiter?: string;
    columnsToArray?: ColumnConfigurationDataType[];
    apiHeaders?: any;
    dataTransformation?: string;
    idColumnTitle?: string;
    data?: any;
}

declare interface DataTableColumnDataType {
    columnTitle?: string;
    columnId: string;
    sortable?: boolean;
    filterOptions?: string[];
    chip?: boolean;
    chipColumnId?: string;
    chipColors?: {
        value: string;
        color: string;
    }[];
    separator?: string;
    align?: 'left' | 'right' | 'center';
    suffix?: string;
    prefix?: string;
    locale?: string;
    precision?: number;
    padZeros?: PadZerosTypes;
    columnWidth?: number;
}

declare interface DirectionalLightConfig extends BaseLightConfig {
    type: 'directional';
    target?: Position;
    castShadow?: boolean;
    shadow?: ShadowConfig;
    position?: Position | 'camera';
}

declare interface DistributionMarkerDataType {
    type: 'median' | 'mean' | 'q1' | 'q3';
    markerStyle?: React.CSSProperties;
    color?: string;
    strokeWidth?: number;
    relativeMarkerLength?: number;
    markerLabel?: {
        showType?: boolean;
        style?: React.CSSProperties;
    };
}

declare interface FileSettingsDataType {
    dataURL: string;
    idColumnName: string;
    fileType?: 'csv' | 'json' | 'api';
    delimiter?: string;
    columnsToArray?: ColumnConfigurationDataType[];
    apiHeaders?: any;
    dataTransformation?: string;
}

declare type FilterUiSettingsDataType = {
    column: string;
    label?: string;
    singleSelect?: boolean;
    clearable?: boolean;
    defaultValue?: string[] | string | number | number[];
    excludeValues?: string[];
    allowSelectAll?: boolean;
    width?: string;
    ui?: 'select' | 'radio';
};

declare interface FogDataType {
    color: string;
    near: number;
    far: number;
}

declare interface GraphConfigurationDataType {
    columnId: string | string[];
    chartConfigId: string;
}

declare interface GraphSettingsDataType {
    colors?: string | string[] | string[][];
    orientation?: 'horizontal' | 'vertical';
    axisTitles?: [string, string];
    graphTitle?: string | React.ReactNode;
    labelOrder?: (string | number)[];
    graphDescription?: string | React.ReactNode;
    footNote?: string | React.ReactNode;
    height?: number;
    width?: number;
    sources?: SourcesDataType[];
    barPadding?: number;
    showTicks?: boolean;
    leftMargin?: number;
    rightMargin?: number;
    truncateBy?: number;
    colorDomain?: string[] | number[];
    colorLegendTitle?: string;
    backgroundColor?: string | boolean;
    padding?: string;
    topMargin?: number;
    bottomMargin?: number;
    relativeHeight?: number;
    showColorScale?: boolean;
    maxValue?: number;
    minValue?: number;
    tooltip?: string | ((_d: any) => React.ReactNode);
    refValues?: ReferenceDataType[];
    graphID?: string;
    highlightedDataPoints?: (string | number)[];
    graphDownload?: boolean;
    sortData?: 'desc' | 'asc';
    dataDownload?: boolean;
    maxRadiusValue?: number;
    leftBarTitle?: string;
    rightBarTitle?: string;
    barColors?: [string, string];
    centerGap?: number;
    columnData?: DataTableColumnDataType[];
    mainText?: string | {
        label: string;
        suffix?: string;
        prefix?: string;
        locale?: string;
        padZeros?: PadZerosTypes;
        precision?: number;
    } | ReactElement;
    subNote?: string;
    radius?: number;
    strokeWidth?: number;
    showValues?: boolean;
    scaleType?: ScaleDataType;
    showColumnLabels?: boolean | ((_d: string) => React.ReactNode);
    showRowLabels?: boolean | ((_d: string) => React.ReactNode);
    noDataColor?: string;
    fillContainer?: boolean;
    numberOfBins?: number;
    donutStrokeWidth?: number;
    barGraphLayout?: 'horizontal' | 'vertical';
    graphType?: 'circlePacking' | 'treeMap' | 'barGraph' | 'donutChart';
    donutColorDomain?: string[];
    lineTitles?: [string, string];
    noOfXTicks?: number | 'showAvailableOnly';
    dateFormat?: string;
    lineColors?: string[];
    sameAxes?: boolean;
    highlightAreaSettings?: HighlightAreaSettingsDataType[] | HighlightAreaSettingsForScatterPlotDataType[];
    labels?: (string | number)[];
    showColorLegendAtTop?: boolean;
    highlightedLines?: (string | number)[];
    fillArea?: boolean | number;
    mapData?: FeatureCollection | string;
    xColorLegendTitle?: string;
    yColorLegendTitle?: string;
    xDomain?: [number, number, number, number];
    yDomain?: [number, number, number, number];
    scale?: number;
    centerPoint?: [number, number];
    mapBorderWidth?: number;
    mapNoDataColor?: string;
    mapBorderColor?: string;
    isWorldMap?: boolean;
    zoomScaleExtend?: [number, number];
    zoomTranslateExtend?: [[number, number], [number, number]];
    highlightedIds?: string[];
    mapProperty?: string;
    mapStyles?: [string, string];
    center?: [number, number];
    zoomLevel?: number;
    mapStyle?: string | {
        style: string;
        name: string;
    }[];
    barTitle?: string;
    lineTitle?: string;
    barColor?: string;
    lineColor?: string;
    showLabels?: boolean | ((d: any) => React.ReactNode);
    xAxisTitle?: string;
    yAxisTitle?: string;
    refXValues?: ReferenceDataType[];
    refYValues?: ReferenceDataType[];
    customHighlightAreaSettings?: CustomHighlightAreaSettingsDataType[];
    maxXValue?: number;
    minXValue?: number;
    maxYValue?: number;
    minYValue?: number;
    axisTitle?: [string, string];
    year?: number | string;
    aggregationMethod?: 'count' | 'max' | 'min' | 'average' | 'sum';
    stripType?: 'strip' | 'dot';
    language?: Languages;
    animate?: boolean | AnimateDataType;
    highlightColor?: string;
    dotOpacity?: number;
    sortParameter?: number | 'diff' | 'total';
    arrowConnector?: boolean;
    connectorStrokeWidth?: number;
    countOnly?: (string | number)[];
    value?: number;
    gridSize?: number;
    unitPadding?: number;
    size?: number;
    totalNoOfDots?: number;
    showStrokeForWhiteDots?: boolean;
    note?: string;
    showNAColor?: boolean;
    minHeight?: number;
    autoPlay?: boolean;
    autoSort?: boolean;
    showOnlyActiveDate?: boolean;
    showDots?: boolean;
    diffAreaColors?: [string, string];
    theme?: 'dark' | 'light';
    uiMode?: 'light' | 'normal';
    maxBarThickness?: number;
    minBarThickness?: number;
    maxNumberOfBars?: number;
    includeLayers?: string[];
    excludeLayers?: string[];
    layerSelection?: {
        layerID: string;
        name: string[];
    }[];
    annotations?: AnnotationSettingsDataType[];
    regressionLine?: boolean | string;
    ariaLabel?: string;
    nodePadding?: number;
    nodeWidth?: number;
    highlightedSourceDataPoints?: string[];
    highlightedTargetDataPoints?: string[];
    defaultLinkOpacity?: number;
    sourceTitle?: string;
    targetTitle?: string;
    sortNodes?: 'asc' | 'desc' | 'mostReadable' | 'none';
    sourceColors?: string[] | string;
    targetColors?: string[] | string;
    sourceColorDomain?: string[];
    targetColorDomain?: string[];
    showIntervalDots?: boolean;
    showIntervalValues?: boolean;
    intervalLineStrokeWidth?: number;
    intervalLineColors?: [string, string];
    intervalAreaColor?: string;
    cardTemplate?: string | ((_d: any) => React.ReactNode);
    cardBackgroundColor?: string;
    legendMaxWidth?: string;
    cardFilters?: {
        column: string;
        label?: string;
        defaultValue?: string | number;
        excludeValues?: (string | number)[];
        width?: string;
    }[];
    cardSortingOptions?: {
        defaultValue?: string;
        options: {
            value: string;
            label: string;
            type: 'asc' | 'desc';
        }[];
        width?: string;
    };
    cardSearchColumns?: string[];
    cardMinWidth?: number;
    textBackground?: boolean;
    headingFontSize?: string;
    centerAlign?: boolean;
    verticalAlign?: 'center' | 'top' | 'bottom';
    resetSelectionOnDoubleClick?: boolean;
    intervalAreaOpacity?: number;
    detailsOnClick?: string | ((_d: any) => React.ReactNode);
    valueColor?: string;
    labelColor?: string;
    noOfYTicks?: number;
    noOfTicks?: number;
    minDate?: string | number;
    maxDate?: string | number;
    colorLegendColors?: string[];
    colorLegendDomain?: string[];
    barAxisTitle?: string;
    allowDataDownloadOnDetail?: string | boolean;
    noOfItemsInAPage?: number;
    curveType?: CurveTypes;
    styles?: StyleObject;
    classNames?: ClassNameObject;
    mapProjection?: MapProjectionTypes;
    filterNA?: boolean;
    fillShape?: boolean;
    colorScaleMaxWidth?: string;
    axisLabels?: (string | number)[];
    minWidth?: string;
    zoomInteraction?: ZoomInteractionTypes;
    layout?: 'primary' | 'secondary';
    qualitativeRangeColors?: string[];
    targetStyle?: 'background' | 'line';
    targetColor?: 'string';
    measureBarWidthFactor?: number;
    mapLegend?: string | React.ReactNode | MapLegendDataType[];
    dimmedOpacity?: number;
    customLayers?: CustomLayerDataType[];
    dashedLines?: (string | number)[];
    dashSettings?: string[];
    labelsToBeHidden?: (string | number)[];
    autoRotate?: boolean;
    enableZoom?: boolean;
    globeMaterial?: any;
    atmosphereColor?: string;
    lineAxisTitle?: string;
    timeline?: TimelineDataType;
    naLabel?: string;
    globeOffset?: [number, number];
    polygonAltitude?: number;
    atmosphereAltitude?: number;
    globeCurvatureResolution?: number;
    lights?: LightConfig[];
    fogSetting?: FogDataType;
    showAxisLabels?: boolean;
    highlightedAltitude?: number;
    selectedId?: string;
    collapseColorScaleByDefault?: boolean;
    dotLegendTitle?: string;
    dotColor?: string;
    dotBorderColor?: string;
    mapColorLegendTitle?: string;
    choroplethScaleType?: Exclude<ScaleDataType, 'linear'>;
    trackColor?: string;
    zoomAndCenterByHighlightedIds?: boolean;
    hideAxisLine?: boolean;
    projectionRotate?: [number, number] | [number, number, number];
    rewindCoordinatesInMapData?: boolean;
    circularBoundary?: boolean;
    showDataMinMax?: boolean;
    showVoronoiTesselation?: boolean;
    mapOverlay?: MapOverlayDataType;
    useVoronoiInteraction?: boolean;
    numberDisplayOptions?: NumberFormatOptions;
    leftLineNumberDisplayOptions?: NumberFormatOptions;
    rightLineNumberDisplayOptions?: NumberFormatOptions;
    barNumberDisplayOptions?: NumberFormatOptions;
    lineNumberDisplayOptions?: NumberFormatOptions;
    xNumberDisplayOptions?: NumberFormatOptions;
    yNumberDisplayOptions?: NumberFormatOptions;
    defaultColor?: string;
    strictValuePosition?: boolean;
    gridIcon?: {
        width?: number;
        height?: number;
        d: string[];
    };
    showTotalValue?: boolean;
    labelPosition?: 'inside' | 'outside' | 'overlap';
    dimmedNodeOpacity?: number;
    labelWidth?: number;
    highlightedLinks?: {
        source: string;
        target: string;
    }[];
    minLabelSize?: number;
    minLabelHeight?: number;
    minLabelWidth?: number;
    minLabelRadius?: number;
    groupOrder?: (string | number)[];
    showGroups?: boolean;
    distributionMarkers?: DistributionMarkerDataType[];
    highlightSameLabelOnHover?: boolean;
    maxGroupThickness?: number;
    minGroupThickness?: number;
    groupPadding?: number;
    showCostalBorder?: boolean;
    showUNBorder?: boolean;
    showAksaiChinAsStriped?: boolean;
    isDisputedAreasInteractive?: boolean;
    repositionOverlappingLabels?: boolean;
    cornerRadius?: number;
}

declare interface HighlightAreaSettingsDataType {
    coordinates: [number | string | null, number | string | null];
    style?: React.CSSProperties;
    className?: string;
    color?: string;
    strokeWidth?: number;
}

declare interface HighlightAreaSettingsForScatterPlotDataType {
    coordinates: [number | null, number | null, number | null, number | null];
    style?: React.CSSProperties;
    className?: string;
    color?: string;
    strokeWidth?: number;
}

declare type HighlightDataPointSettingsDataType = {
    column: string;
    label?: string;
    defaultValues?: (string | number)[];
    excludeValues?: (string | number)[];
    width?: string;
};

declare type Languages = 'en' | 'ar' | 'az' | 'bn' | 'cy' | 'he' | 'hi' | 'ja' | 'ka' | 'km' | 'ko' | 'my' | 'ne' | 'zh' | 'custom';

declare type LightConfig = AmbientLightConfig | DirectionalLightConfig | PointLightConfig | SpotLightConfig;

declare interface MapLegendDataType {
    mapStyleName: string;
    legend: string | React.ReactNode;
}

declare interface MapOverlayDataType {
    mapData: FeatureCollection | string;
    mapBorderWidth?: number;
    mapBorderColor?: string;
}

declare type MapProjectionTypes = 'mercator' | 'equalEarth' | 'naturalEarth' | 'orthographic';

declare interface NumberFormatOptions {
    locale?: string;
    precision?: number;
    prefix?: string;
    suffix?: string;
    padZeros?: PadZerosTypes;
}

declare type PadZerosTypes = 'all' | 'decimal' | 'none';

declare interface PointLightConfig extends BaseLightConfig {
    type: 'point';
    distance?: number;
    decay?: number;
    position?: Position | 'camera';
}

declare interface Position {
    x: number;
    y: number;
    z: number;
}

declare interface Props {
    config: string | ConfigObject;
}

declare interface ReferenceDataType {
    value: number | null;
    text: string;
    color?: string;
    styles?: {
        line?: React.CSSProperties;
        text?: React.CSSProperties;
    };
    classNames?: {
        line?: string;
        text?: string;
    };
}

declare type ScaleDataType = 'categorical' | 'linear' | 'threshold';

declare interface ShadowConfig {
    mapSize: {
        width: number;
        height: number;
    };
    camera: {
        near: number;
        far: number;
    };
}

export declare function SingleGraphDashboardThreeDGraphsFromConfig(props: Props): JSX.Element;

declare interface SourcesDataType {
    source: string;
    link?: string;
}

declare interface SpotLightConfig extends BaseLightConfig {
    type: 'spot';
    target?: Position;
    distance?: number;
    angle?: number;
    penumbra?: number;
    decay?: number;
    castShadow?: boolean;
    shadow?: ShadowConfig;
    position?: Position | 'camera';
}

declare interface StyleObject {
    title?: React.CSSProperties;
    footnote?: React.CSSProperties;
    source?: React.CSSProperties;
    description?: React.CSSProperties;
    graphContainer?: React.CSSProperties;
    tooltip?: React.CSSProperties;
    xAxis?: AxesStyleObject;
    yAxis?: AxesStyleObject;
    graphObjectValues?: React.CSSProperties;
    dataConnectors?: React.CSSProperties;
    mouseOverLine?: React.CSSProperties;
    regLine?: React.CSSProperties;
    dataCards?: React.CSSProperties;
    modal?: React.CSSProperties;
    area?: React.CSSProperties;
}

declare type ThreeDGraphType = 'threeDGlobe';

declare interface TimelineDataType {
    autoplay: boolean;
    enabled: boolean;
    showOnlyActiveDate: boolean;
    speed?: number;
    dateFormat?: string;
    color?: Exclude<Color, 'background' | 'surface' | 'surface-2xs' | 'surface-xs' | 'surface-sm' | 'surface-md' | 'surface-lg' | 'surface-xl' | 'surface-2xl' | 'surface-3xl' | 'surface-4xl' | 'foreground'>;
}

declare type ZoomInteractionTypes = 'scroll' | 'ctrlScroll' | 'button' | 'noZoom';

export { }