@datawheel/data-explorer 0.3.1 → 0.3.3

package/dist/main.d.ts

@@ -0,0 +1,1098 @@
+import React, { ReactNode } from 'react';
+import { MRT_TableInstance, MRT_ColumnDef, MRT_PaginationState, MRT_TableOptions } from 'mantine-react-table';
+import { TranslationContextProps } from '@datawheel/use-translation';
+import { CSSObject } from '@mantine/core';
+import { StepType, TourProps } from '@reactour/tour';
+import * as _reduxjs_toolkit from '@reduxjs/toolkit';
+import { StateFromReducersMapObject, ThunkAction, Action } from '@reduxjs/toolkit';
+import * as redux from 'redux';
+
+declare enum Aggregator {
+    AVERAGE = "Average",
+    COUNT = "Count",
+    MAX = "Max",
+    MEDIAN = "Median",
+    MIN = "Min",
+    MODE = "Mode",
+    SUM = "Sum",
+    BASICGROUPEDMEDIAN = "BasicGroupedMedian",
+    CALCULATEDMOE = "CalculatedMoe",
+    QUANTILE = "Quantile",
+    REPLICATEWEIGHTMOE = "ReplicateWeightMoe",
+    WEIGHTEDAVERAGE = "WeightedAverage",
+    WEIGHTEDAVERAGEMOE = "WeightedAverageMoe",
+    WEIGHTEDSUM = "WeightedSum",
+    DISTINCTCOUNT = "DistinctCount"
+}
+declare enum Comparison {
+    "!=" = "neq",
+    "<" = "lt",
+    "<=" = "lte",
+    "<>" = "neq",
+    "=" = "eq",
+    ">" = "gt",
+    ">=" = "gte",
+    eq = "eq",
+    EQ = "eq",
+    gt = "gt",
+    GT = "gt",
+    gte = "gte",
+    GTE = "gte",
+    lt = "lt",
+    LT = "lt",
+    lte = "lte",
+    LTE = "lte",
+    NEQ = "neq",
+    neq = "neq"
+}
+declare enum DimensionType {
+    GEO = "geo",
+    STANDARD = "standard",
+    TIME = "time"
+}
+declare enum Format {
+    csv = "csv",
+    jsonrecords = "jsonrecords",
+    parquet = "parquet",
+    tsv = "tsv",
+    xlsx = "xlsx"
+}
+
+type Annotations = Record<string, string | undefined>;
+interface TesseractDataRequest {
+    cube: string;
+    /**
+     * @example LevelName,LevelName,LevelName
+     */
+    drilldowns: string;
+    /**
+     * @example Measure,Measure,Measure
+     */
+    measures: string;
+    /**
+     * @example Level:key,key,key;Level:key,key,key
+     */
+    exclude?: string;
+    /**
+     * @example Measure.gt.10000.and.lt.60000,Measure.lt.100000
+     */
+    filters?: string;
+    /**
+     * @example Level:key,key,key;Level:key,key,key
+     */
+    include?: string;
+    /**
+     * A single number is limit; a pair of numbers are limit, offset.
+     * @example 2,5
+     */
+    limit?: string;
+    /**
+     * @example es
+     */
+    locale?: string;
+    /**
+     * A boolean enables parents for all levels in the request.
+     * You can also pick specific Levels from the drilldown list.
+     * @example true
+     * @example Level,Level
+     */
+    parents?: boolean | string;
+    /**
+     * @example Property,Property
+     */
+    properties?: string;
+    /**
+     * A boolean sets rankings for all measures in descending order.
+     * If setting measure names, orden can be set with or without a leading minus.
+     * @example true
+     * @example Measure,-Measure
+     */
+    ranking?: boolean | string;
+    /**
+     * @example Measure.asc
+     * @example Property.desc
+     */
+    sort?: string;
+    /**
+     * Determines if the request should return the full cardinality of available
+     * options, even if their associated value is null.
+     * @default true
+     */
+    sparse?: boolean;
+    /**
+     * @example month.latest.6
+     * @example Level.oldest
+     */
+    time?: string;
+    /**
+     * Slices the resulting items to only the highest/lowest N items by the value
+     * of Measure, for all the subgroups signaled by the Level parameters.
+     * @example 10.Level.Measure.asc
+     * @example 3.Level,Level.Measure.desc
+     */
+    top?: string;
+    /**
+     * Calculates the growth in Measure for each Level using one of these methods:
+     * - fixed: Calculates growth against a fixed member key from Level
+     * - period: Calculates growth comparing a time point with its previous N point
+     * @example Level.Measure.fixed.201804
+     * @example Level.Measure.period.3
+     */
+    growth?: string;
+}
+interface TesseractMembersRequest {
+    cube: string;
+    level: string;
+    limit?: string;
+    locale?: string;
+    parents?: boolean;
+    search?: string;
+}
+interface TesseractMembersResponse {
+    /** Name of the relevant level */
+    name: string;
+    /** Public localized name of the relevant level */
+    caption: string;
+    dimensionType: DimensionType;
+    dimension: string;
+    hierarchy: string;
+    /** Depth of the level in its Hierarchy */
+    depth: number;
+    /** Metadata for the level */
+    annotations: Annotations;
+    /** Child Properties from this level */
+    properties: TesseractProperty[];
+    /** Data type of each column in the members array */
+    dtypes: {
+        [K in keyof TesseractMember]: string;
+    };
+    /** The actual list of members for the level */
+    members: TesseractMember[];
+}
+interface TesseractStatus {
+    module: string;
+    version: string;
+    debug: false | Record<string, string>;
+    extras: Record<string, string>;
+}
+interface TesseractSchema {
+    name: string;
+    locales: string[];
+    default_locale: string;
+    annotations: Annotations;
+    cubes: TesseractCube[];
+}
+interface TesseractCube {
+    name: string;
+    caption: string;
+    annotations: Annotations;
+    dimensions: TesseractDimension[];
+    measures: TesseractMeasure[];
+}
+interface TesseractMeasure {
+    name: string;
+    caption: string;
+    annotations: Annotations;
+    aggregator: Aggregator;
+    attached: TesseractMeasure[];
+}
+interface TesseractDimension {
+    name: string;
+    caption: string;
+    annotations: Annotations;
+    type: DimensionType;
+    hierarchies: TesseractHierarchy[];
+    default_hierarchy: string;
+}
+interface TesseractHierarchy {
+    name: string;
+    caption: string;
+    annotations: Annotations;
+    levels: TesseractLevel[];
+}
+interface TesseractLevel {
+    name: string;
+    caption: string;
+    annotations: Annotations;
+    depth: number;
+    properties: TesseractProperty[];
+}
+interface TesseractProperty {
+    name: string;
+    caption: string;
+    annotations: Annotations;
+    type: string;
+}
+interface TesseractMember {
+    /** The unique ID for this member */
+    key: string | number;
+    /** The localized label for this member */
+    caption?: string;
+    /** A list of direct ancestor members, one per level above this one */
+    ancestor?: TesseractMember[];
+}
+
+interface ComplexityStatus {
+    module: string;
+    version: string;
+    debug: false | Record<string, string>;
+    extras: Record<string, string>;
+}
+interface CommonRequest {
+    alias?: Record<string, string>;
+    filter?: Record<string, string>;
+    locale?: string;
+}
+interface RcaRequest extends CommonRequest {
+    cube: string;
+    activity: string;
+    location: string;
+    measure: string;
+    cuts?: Record<string, string>;
+    parents?: boolean;
+    threshold?: string[];
+}
+interface ComplexityRequest extends RcaRequest {
+    ascending?: boolean;
+    cutoff?: number;
+    iterations?: number;
+    rank?: boolean;
+}
+interface RelatednessRequest extends RcaRequest {
+    ascending?: boolean;
+    cutoff?: number;
+    rank?: boolean;
+}
+interface OpportunityRequest extends RcaRequest {
+    ascending?: boolean;
+    cutoff?: number;
+    rank?: boolean;
+}
+interface GiniRequest extends RcaRequest {
+    gini_cube: string;
+    gini_location: string;
+    gini_measure: string;
+    ascending?: boolean;
+    cutoff?: number;
+    rank?: boolean;
+}
+interface EmissionsRequest extends RcaRequest {
+    emissions_cube: string;
+    emissions_location: string;
+    emissions_measure: string;
+    ascending?: boolean;
+    cutoff?: number;
+    rank?: boolean;
+}
+
+declare class ComplexityModuleClient {
+    baseURL: string;
+    requestConfig: RequestInit;
+    constructor(baseURL?: string, config?: RequestInit);
+    fetchStatus(params: {
+        signal?: AbortSignal;
+    }): Promise<ComplexityStatus>;
+    fetchSchema(params: {
+        locale?: string;
+        signal?: AbortSignal;
+    }): Promise<TesseractSchema>;
+    fetchCube(params: {
+        cube: string;
+        locale?: string;
+        signal?: AbortSignal;
+    }): Promise<TesseractCube>;
+    fetchData(type: "rca", params: {
+        request: RcaRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+    fetchData(type: "eci", params: {
+        request: ComplexityRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+    fetchData(type: "pci", params: {
+        request: ComplexityRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+    fetchData(type: "relatedness", params: {
+        request: RelatednessRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+    fetchData(type: "opportunity_gain", params: {
+        request: OpportunityRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+    fetchData(type: "pgi", params: {
+        request: GiniRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+    fetchData(type: "peii", params: {
+        request: EmissionsRequest;
+        format: Format;
+        signal?: AbortSignal;
+    }): any;
+}
+
+declare class TesseractModuleClient {
+    baseURL: string;
+    requestConfig: RequestInit;
+    constructor(baseURL?: string, config?: RequestInit);
+    fetchStatus(params: {
+        signal?: AbortSignal;
+    }): Promise<TesseractStatus>;
+    fetchSchema(params: {
+        locale?: string;
+        signal?: AbortSignal;
+    }): Promise<TesseractSchema>;
+    fetchCube(params: {
+        cube: string;
+        locale?: string;
+        signal?: AbortSignal;
+    }): Promise<TesseractCube>;
+    fetchData(params: {
+        request: TesseractDataRequest;
+        format: `${Format}`;
+        signal?: AbortSignal;
+    }): Promise<Response>;
+    fetchMembers(params: {
+        request: TesseractMembersRequest;
+        signal?: AbortSignal;
+    }): Promise<TesseractMembersResponse>;
+}
+
+interface QueryItem {
+    created: string;
+    isDirty: boolean;
+    key: string;
+    label: string;
+    panel: string | null;
+    params: QueryParams;
+    result: QueryResult;
+}
+interface QueryParams {
+    booleans: Record<string, undefined | boolean>;
+    cube: string;
+    cuts: Record<string, CutItem>;
+    drilldowns: Record<string, DrilldownItem>;
+    filters: Record<string, FilterItem>;
+    locale: string | undefined;
+    measures: Record<string, MeasureItem>;
+    isPreview: boolean;
+    pagiLimit: number;
+    pagiOffset: number;
+    sortDir: "asc" | "desc";
+    sortKey: string | undefined;
+}
+interface QueryResult<D = Record<string, unknown>> {
+    data: D[];
+    page: {
+        limit: number;
+        offset: number;
+        total: number;
+    };
+    types: Record<string, AnyResultColumn>;
+    headers?: Record<string, string>;
+    status: number;
+    url: string;
+}
+interface ResultEntityType {
+    level: TesseractLevel;
+    property: TesseractProperty;
+    measure: TesseractMeasure;
+}
+interface ResultColumn<T extends keyof ResultEntityType> {
+    label: string;
+    localeLabel: string;
+    isId: boolean;
+    entity: ResultEntityType[T];
+    entityType: T;
+    valueType: "boolean" | "number" | "string";
+    range?: [number, number];
+}
+type AnyResultColumn = ResultColumn<"level"> | ResultColumn<"measure"> | ResultColumn<"property">;
+interface QueryParamsItem {
+    active: boolean;
+    readonly key: string;
+}
+interface CutItem extends QueryParamsItem {
+    dimension: string;
+    hierarchy: string;
+    level: string;
+    members: string[];
+}
+interface DrilldownItem extends QueryParamsItem {
+    captionProperty: string;
+    dimension: string;
+    hierarchy: string;
+    level: string;
+    properties: PropertyItem[];
+    members: {
+        key: string | number;
+        caption?: string;
+    }[];
+}
+interface FilterItem extends QueryParamsItem {
+    measure: string;
+    conditionOne: [`${Comparison}`, string, number];
+    conditionTwo?: [`${Comparison}`, string, number];
+    joint: "and" | "or";
+}
+interface MeasureItem extends QueryParamsItem {
+    name: string;
+    caption?: string;
+}
+interface PropertyItem extends QueryParamsItem {
+    level: string;
+    name: string;
+}
+
+interface FileDescriptor {
+    content: Blob | string;
+    extension: string;
+    name: string;
+}
+type Formatter = (value: number | null, locale?: string) => string;
+interface PanelDescriptor {
+    key: string;
+    label: string;
+    component: React.ComponentType<ViewProps>;
+}
+interface ViewProps<TData extends Record<string, any> = Record<string, string | number>> {
+    className?: string;
+    cube: TesseractCube;
+    panelKey: string | null;
+    params: QueryParams;
+    result: QueryResult<TData>;
+    table?: MRT_TableInstance<TData & Record<string, any>>;
+    isError?: boolean;
+    isLoading?: boolean;
+    data?: Record<string, string | number>[];
+    columns?: MRT_ColumnDef<TData>[];
+    pagination?: MRT_PaginationState;
+    setPagination?: React.Dispatch<React.SetStateAction<MRT_PaginationState>>;
+}
+
+/** */
+declare function DebugView(props: ViewProps): React.JSX.Element;
+
+declare const defaultTranslation: {
+    action_copy: string;
+    action_copy_done: string;
+    action_download: string;
+    action_open: string;
+    action_reload: string;
+    sidebar: {
+        dataset: string;
+    };
+    comparison: {
+        BT: string;
+        EQ: string;
+        GT: string;
+        GTE: string;
+        LT: string;
+        LTE: string;
+        NEQ: string;
+    };
+    debug_view: {
+        tab_label: string;
+        httpheaders: string;
+        jssource_prefix: string;
+        jssource_suffix: string;
+        url_aggregate: string;
+        url_logiclayer: string;
+    };
+    direction: {
+        ASC: string;
+        DESC: string;
+    };
+    formats: {
+        csv: string;
+        json: string;
+        tsv: string;
+        parquet: string;
+        jsonrecords: string;
+        xlsx: string;
+    };
+    loading: {
+        title: string;
+        message_heavyquery: string;
+        message_default: string;
+    };
+    params: {
+        add_metadata: string;
+        action_clear: string;
+        action_clear_description: string;
+        action_execute: string;
+        add_columns: string;
+        column_title: string;
+        current_endpoint: string;
+        dimmenu_abbrjoint: string;
+        dimmenu_dimension: string;
+        dimmenu_hierarchy: string;
+        dimmenu_level: string;
+        filter_mode: string;
+        filter_by: string;
+        error_no_cut_selected_detail: string;
+        error_no_cut_selected_title: string;
+        error_no_dimension_selected_detail: string;
+        error_no_dimension_selected_title: string;
+        error_fetchmembers_detail: string;
+        error_fetchmembers_title: string;
+        label_amount: string;
+        label_boolean_debug: string;
+        label_boolean_distinct: string;
+        label_boolean_exclude_default_members: string;
+        label_boolean_full_results: string;
+        label_boolean_nonempty: string;
+        label_boolean_parents: string;
+        label_boolean_sparse: string;
+        label_clear: string;
+        label_cube: string;
+        label_cuts_filterby_id: string;
+        label_cuts_filterby_name: string;
+        label_cuts_filterby_any: string;
+        label_fullscreen: string;
+        label_locale: string;
+        label_search: string;
+        label_no_results: string;
+        label_dataset: string;
+        label_localeoption: string;
+        label_measure: string;
+        label_pagination_limit: string;
+        label_pagination_offset: string;
+        label_sorting_key: string;
+        label_sorting_order: string;
+        label_source: string;
+        label_subtopic: string;
+        label_table: string;
+        label_timelevel: string;
+        label_topic: string;
+        search_placeholder: string;
+        tag_cuts_plural: string;
+        tag_cuts: string;
+        tag_drilldowns_abbrjoint: string;
+        tag_drilldowns: string;
+        title_area_cuts: string;
+        title_area_drilldowns: string;
+        title_area_filters: string;
+        title_area_measures: string;
+        title_area_options: string;
+        title_area_pagination: string;
+        title_area_sorting: string;
+        title_caption: string;
+        title_downloaddata: string;
+        title_members: string;
+        title_properties: string;
+        tooltip_area_cuts: string;
+        tooltip_area_drilldowns: string;
+        tooltip_area_filters: string;
+        tooltip_area_measures: string;
+        tooltip_area_options: string;
+    };
+    pivot_view: {
+        tab_label: string;
+        error_missingparams: string;
+        error_onedimension: string;
+        error_internal: string;
+        error_internal_detail: string;
+        label_ddcolumn: string;
+        label_ddcolumnprop: string;
+        label_ddrow: string;
+        label_ddrowprop: string;
+        label_formatter: string;
+        label_valmeasure: string;
+        loading_details: string;
+        loading_title: string;
+        title_download: string;
+        title_params: string;
+        warning: string;
+        warning_notsummeasure: string;
+        warning_propertypivot: string;
+        warning_sumdimensions: string;
+    };
+    placeholders: {
+        incomplete: string;
+        unselected: string;
+        none: string;
+    };
+    previewMode: {
+        btn_get_all: string;
+        btn_get_preview: string;
+        description_full: string;
+        description_preview: string;
+        title_full: string;
+        title_preview: string;
+    };
+    queries: {
+        action_create: string;
+        action_parse: string;
+        error_not_query: string;
+        error_no_drilldowns: string;
+        error_no_measures: string;
+        error_one_hierarchy_per_dimension: string;
+        error_one_cut_per_dimension: string;
+        column_title: string;
+        unset_parameters: string;
+    };
+    results: {
+        error_execquery_detail: string;
+        error_disconnected_title: string;
+        error_serveroffline_title: string;
+        error_serveroffline_detail: string;
+        error_emptyresult_title: string;
+        error_emptyresult_detail: string;
+        count_rows: string;
+        count_rows_plural: string;
+    };
+    selectlevel_placeholder: string;
+    selectmeasure_placeholder: string;
+    selecttimelevel_placeholder: string;
+    table_view: {
+        tab_label: string;
+        numeral_format: string;
+        sort_asc: string;
+        sort_desc: string;
+    };
+    tour: {
+        controls: {
+            prev: string;
+            next: string;
+            help: string;
+        };
+        steps: {
+            welcome: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            locale: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            dataset: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            search: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            table: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            columns: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            filters: {
+                title: string;
+                text1: string;
+                text2: string;
+            };
+            download: {
+                title: string;
+                text1: string;
+            };
+            api: {
+                title: string;
+                text1: string;
+            };
+            vizbuilderTab: {
+                title: string;
+                text1: string;
+            };
+            last: {
+                title: string;
+                text: string;
+                button: string;
+            };
+        };
+    };
+    transfer_input: {
+        count_hidden: string;
+        count_hidden_plural: string;
+        search_placeholder: string;
+        select_all: string;
+        unselect_all: string;
+        select_filtered: string;
+        unselect_filtered: string;
+        selected_items: string;
+        unselected_items: string;
+    };
+    vizbuilder: {
+        action_close: string;
+        action_enlarge: string;
+        action_fileissue: string;
+        action_retry: string;
+        aggregator: {
+            average: string;
+            max: string;
+            min: string;
+        };
+        chart_labels: {
+            ci: string;
+            moe: string;
+            source: string;
+            collection: string;
+        };
+        error: {
+            detail: string;
+            message: string;
+            title: string;
+        };
+        list: {
+            join: string;
+            suffix: string;
+            prefix: string;
+        };
+        title: {
+            series: string;
+            series_members: string;
+            main: string;
+            main_over_period: string;
+            main_on_period: string;
+            total: string;
+        };
+        transient: {
+            title_loading: string;
+            title_empty: string;
+            description_empty: string;
+        };
+    };
+};
+type TranslationDict = typeof defaultTranslation;
+declare const useTranslation: any;
+declare const TranslationConsumer: any;
+
+interface ExplorerStepType extends StepType {
+    actionBefore?: () => void;
+}
+type TourConfig = {
+    extraSteps?: ExplorerStepType[];
+    introImage?: React.ReactNode;
+    tourProps?: Partial<TourProps>;
+};
+interface TourStepsPropsType {
+    title: string;
+    texts: string[] | string;
+}
+
+interface ToolBarButtonProps {
+    icon: ReactNode;
+    label?: string;
+    onClick?: () => void;
+}
+interface ToolbarConfigType {
+    buttons: ToolBarButtonProps[];
+    showLabels: Boolean;
+}
+declare function ToolbarButton({ icon, label, onClick }: ToolBarButtonProps): React.JSX.Element;
+
+type Pagination = {
+    rowsLimits: number[];
+    defaultLimit: Pagination["rowsLimits"][number];
+};
+/**
+ * Main DataExplorer component
+ * This components wraps the interface components in the needed Providers,
+ * and pass the other properties to them.
+ */
+declare function ExplorerComponent<Locale extends string>(props: {
+    measuresActive?: number;
+    pagination?: Pagination;
+    /**
+     * The main server endpoint.
+     */
+    serverURL: string;
+    /**
+     * Additional request parameters for all requests against the server.
+     * Uses the same format used by the second parameter of the fetch API.
+     */
+    serverConfig?: RequestInit;
+    /**
+     * The locale to use when retrieving the schema from the server the first time.
+     * If not set, the server will use the default locale set in its configuration.
+     */
+    defaultDataLocale?: string;
+    /**
+     * Defines the default cube that will be opened when the component first loads.
+     * @default undefined
+     */
+    defaultCube?: string | undefined;
+    /**
+     * Specifies which property should be used to filter elements in the member
+     * selection control of the Cuts parameter area.
+     * @default "id"
+     */
+    defaultMembersFilter?: "id" | "name" | "any";
+    /**
+     * Defines the parameter panel which will be opened when the component first loads.
+     * Available options are `measures`, `drilldowns`, `cuts`, and `options`.
+     * @default "measures"
+     */
+    defaultOpenParams?: "measures" | "drilldowns" | "cuts" | "options";
+    /**
+     * The locale to use in the Explorer component UI.
+     * This value is passed to the Translation utility and controls the language
+     * for the labels throughout the user interface. Must be equal to one of the
+     * keys in the object provided to the `translations` property.
+     * @default "en"
+     */
+    locale?: Locale;
+    /**
+     * Defines an index of formatter functions available to the measures shown
+     * in the app, besides a limited list of default ones. The key used comes
+     * from `measure.annotations.units_of_measurement`, if present.
+     */
+    formatters?: Record<string, Formatter>;
+    /**
+     * Defines an alternative height for the component structure.
+     * @default "100vh"
+     */
+    height?: CSSObject["height"];
+    /**
+     * The list of tabs to offer to the user to render the results.
+     * Must be an array of objects with the following properties:
+     * - `key`: a string to distinguish each panel, will be used in the URL params
+     * - `label`: a string used as the title for the panel in the tab bar.
+     * It will be passed through the internal translation function, so can be
+     * localized via the `translations` property or used directly as is.
+     * - `component`: a non-hydrated React Component.
+     * This will be passed the needed properties according to the specification.
+     * Rendering the panel supports the use of `React.lazy` to defer the load of
+     * heavy dependencies.
+     */
+    panels?: PanelDescriptor[];
+    /**
+     * A component that is rendered to display the default "splash screen";
+     * the screen that is shown in the results panel when there is no query,
+     * or a query has been dirtied.
+     */
+    splash?: React.ComponentType<{
+        translation: TranslationContextProps;
+    }>;
+    toolbarConfig?: Partial<ToolbarConfigType>;
+    /**
+     * Tour configuration
+     */
+    tourConfig?: Partial<TourConfig>;
+    /**
+     * The Translation labels to use in the UI.
+     */
+    translations?: Record<Locale, TranslationDict>;
+    /**
+     * Determines whether Explorer should be rendered within a MantineProvider
+     * @default true
+     */
+    withinMantineProvider?: boolean;
+    /**
+     * Determines whether Explorer should be rendered within a Redux Provider,
+     * encapsulating its state, and making easier to install.
+     * @default false
+     */
+    withinReduxProvider?: boolean;
+    /**
+     * Enables multiple queries mode.
+     * This adds a column where the user can quickly switch between queries,
+     * like tabs in a browser.
+     * @default false
+     */
+    withMultiQuery?: boolean;
+    /**
+     * Enables browser permalink synchronization.
+     * @default false
+     */
+    withPermalink?: boolean;
+}): React.JSX.Element;
+declare namespace ExplorerComponent {
+    var displayName: string;
+}
+
+/** */
+declare function PivotView<TData extends Record<string, unknown>>(props: {} & ViewProps<TData> & MRT_TableOptions<TData>): React.JSX.Element;
+
+type TData = Record<string, any> & Record<string, string | number>;
+type TableView = {
+    table: MRT_TableInstance<TData>;
+    getColumn(id: string): AnyResultColumn | undefined;
+    columns: AnyResultColumn[];
+} & ViewProps;
+declare function TableView({ table, result, isError, isLoading, data, pagination, setPagination }: TableView): React.JSX.Element;
+declare namespace TableView {
+    var displayName: string;
+}
+
+declare const reducerMap: {
+    explorerLoading: redux.Reducer<LoadingState>;
+    explorerQueries: redux.Reducer<QueriesState>;
+    explorerServer: redux.Reducer<ServerState>;
+};
+declare const reducer: redux.Reducer<redux.CombinedState<{
+    explorerLoading: LoadingState;
+    explorerQueries: QueriesState;
+    explorerServer: ServerState;
+}>, redux.AnyAction>;
+/**
+ * Inyects the Client dependency to the thunk's extra argument.
+ */
+declare function thunkExtraArg(): {
+    tesseract: TesseractModuleClient;
+    complexity: ComplexityModuleClient;
+    previewLimit: number;
+};
+type ExplorerThunkArg = ReturnType<typeof thunkExtraArg>;
+type ExplorerState = StateFromReducersMapObject<typeof reducerMap>;
+type ExplorerThunk<ReturnType = void> = ThunkAction<ReturnType, ExplorerState, ExplorerThunkArg, Action<string>>;
+
+declare const LOADINGSTATUS: {
+    readonly FETCHING: "FETCHING";
+    readonly SUCCESS: "SUCCESS";
+    readonly FAILURE: "FAILURE";
+};
+type LoadingStatus = typeof LOADINGSTATUS[keyof (typeof LOADINGSTATUS)];
+interface LoadingMessage {
+    type: string;
+    [params: string]: string;
+}
+interface LoadingState {
+    error: string | null;
+    loading: boolean;
+    message?: LoadingMessage;
+    status: LoadingStatus;
+    trigger: string | null;
+}
+
+interface QueriesState {
+    current: string;
+    itemMap: Record<string, QueryItem>;
+}
+
+interface ServerState {
+    cubeMap: Record<string, TesseractCube>;
+    locale: string;
+    localeOptions: string[];
+    online: boolean | undefined;
+    url: string;
+}
+
+type ExplorerActionMap = typeof actions;
+declare const actions: {
+    willDownloadQuery(format: `${Format}`): ExplorerThunk<Promise<FileDescriptor>>;
+    willExecuteQuery(params?: {
+        limit?: number;
+        offset?: number;
+    }): ExplorerThunk<Promise<void>>;
+    willFetchQuery(params?: {
+        limit?: number;
+        offset?: number;
+    }): ExplorerThunk<Promise<QueryResult>>;
+    willFetchMembers(level: string, localeStr?: string, cubeName?: string): ExplorerThunk<Promise<TesseractMembersResponse>>;
+    willHydrateParams(suggestedCube?: string): ExplorerThunk<Promise<void>>;
+    willParseQueryUrl(url: string | URL): ExplorerThunk<Promise<void>>;
+    willReloadCubes(params?: {
+        locale: {
+            code: string;
+        };
+    }): ExplorerThunk<Promise<{
+        [k: string]: TesseractCube;
+    }>>;
+    willRequestQuery(): ExplorerThunk<Promise<void>>;
+    willSetCube(cubeName: string, measuresActive?: number, locale?: string): ExplorerThunk<Promise<void>>;
+    willReloadCube({ locale }: {
+        locale: {
+            code: string;
+        };
+    }): ExplorerThunk<Promise<void>>;
+    willSetupClient(baseURL: string, defaultLocale?: string, requestConfig?: RequestInit): ExplorerThunk<Promise<{
+        [k: string]: TesseractCube;
+    }>>;
+    resetQueries: _reduxjs_toolkit.ActionCreatorWithPayload<Record<string, any>, "explorerQueries/resetQueries">;
+    removeQuery: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/removeQuery">;
+    selectQuery: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/selectQuery">;
+    updateQuery: _reduxjs_toolkit.ActionCreatorWithPayload<QueryItem, "explorerQueries/updateQuery">;
+    switchPanel: _reduxjs_toolkit.ActionCreatorWithPayload<string | null, "explorerQueries/switchPanel">;
+    removeCut: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/removeCut">;
+    removeDrilldown: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/removeDrilldown">;
+    removeMeasure: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/removeMeasure">;
+    removeFilter: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/removeFilter">;
+    resetAllParams: _reduxjs_toolkit.ActionCreatorWithPayload<Partial<QueryParams>, "explorerQueries/resetAllParams">;
+    resetCuts: _reduxjs_toolkit.ActionCreatorWithPayload<Record<string, CutItem>, "explorerQueries/resetCuts">;
+    resetDrilldowns: _reduxjs_toolkit.ActionCreatorWithPayload<Record<string, DrilldownItem>, "explorerQueries/resetDrilldowns">;
+    resetFilters: _reduxjs_toolkit.ActionCreatorWithPayload<Record<string, FilterItem>, "explorerQueries/resetFilters">;
+    resetMeasures: _reduxjs_toolkit.ActionCreatorWithPayload<Record<string, MeasureItem>, "explorerQueries/resetMeasures">;
+    updateIsPreview: _reduxjs_toolkit.ActionCreatorWithOptionalPayload<boolean | undefined, "explorerQueries/updateIsPreview">;
+    updateBoolean: _reduxjs_toolkit.ActionCreatorWithPayload<{
+        key: string;
+        value?: boolean;
+    }, "explorerQueries/updateBoolean">;
+    updateCube: _reduxjs_toolkit.ActionCreatorWithPayload<{
+        cube: string;
+        measures: Record<string, MeasureItem>;
+        drilldowns: Record<string, DrilldownItem>;
+    }, "explorerQueries/updateCube">;
+    updateCut: _reduxjs_toolkit.ActionCreatorWithPayload<CutItem, "explorerQueries/updateCut">;
+    updateDrilldown: _reduxjs_toolkit.ActionCreatorWithPayload<DrilldownItem, "explorerQueries/updateDrilldown">;
+    updateFilter: _reduxjs_toolkit.ActionCreatorWithPayload<FilterItem, "explorerQueries/updateFilter">;
+    updateLocale: _reduxjs_toolkit.ActionCreatorWithPayload<string, "explorerQueries/updateLocale">;
+    updateMeasure: _reduxjs_toolkit.ActionCreatorWithPayload<MeasureItem, "explorerQueries/updateMeasure">;
+    updatePagination: _reduxjs_toolkit.ActionCreatorWithPayload<{
+        limit: number;
+        offset: number;
+    }, "explorerQueries/updatePagination">;
+    updateSorting: _reduxjs_toolkit.ActionCreatorWithPayload<{
+        key: string;
+        dir: "asc" | "desc";
+    }, "explorerQueries/updateSorting">;
+    clearSorting: _reduxjs_toolkit.ActionCreatorWithoutPayload<"explorerQueries/clearSorting">;
+    updateResult: _reduxjs_toolkit.ActionCreatorWithPayload<QueryResult<Record<string, unknown>>, "explorerQueries/updateResult">;
+    setLoadingState(status: LoadingStatus, message?: string): {
+        readonly type: "explorerLoading/setLoadingState:FETCHING" | "explorerLoading/setLoadingState:SUCCESS" | "explorerLoading/setLoadingState:FAILURE";
+        readonly payload: string | undefined;
+    };
+    setLoadingMessage: _reduxjs_toolkit.ActionCreatorWithPayload<LoadingMessage, "explorerLoading/setLoadingMessage">;
+    updateServer: _reduxjs_toolkit.ActionCreatorWithPayload<Partial<ServerState>, "explorerServer/updateServer">;
+    resetServer: _reduxjs_toolkit.ActionCreatorWithoutPayload<"explorerServer/resetServer">;
+};
+
+type ExplorerBoundActionMap = {
+    [K in keyof ExplorerActionMap]: ExplorerActionMap[K] extends (...args: infer Params) => (...args: any[]) => infer R ? (...args: Params) => R : ExplorerActionMap[K];
+};
+interface SettingsContextProps {
+    actions: ExplorerBoundActionMap;
+    defaultMembersFilter: "id" | "name" | "any";
+    formatters: Record<string, Formatter>;
+    previewLimit: number;
+    panels: PanelDescriptor[];
+    paginationConfig: Pagination;
+    measuresActive?: number;
+    toolbarConfig?: ToolbarConfigType;
+}
+/**
+ * A wrapper for the Consumer, for use with class components.
+ */
+declare function SettingsConsumer(props: React.ConsumerProps<SettingsContextProps>): React.JSX.Element;
+/**
+ * The React hook associated to the settings context.
+ */
+declare function useSettings(): SettingsContextProps;
+
+declare function VizbuilderView(props: {
+    cube: TesseractCube;
+    params: QueryParams;
+    result: QueryResult;
+}): React.JSX.Element;
+
+declare function TourStep(props: TourStepsPropsType): React.JSX.Element;
+
+export { DebugView, ExplorerComponent as Explorer, type ExplorerState, type ExplorerStepType, PivotView, SettingsConsumer, TableView, ToolbarButton, TourStep, TranslationConsumer, type TranslationDict, type ViewProps, VizbuilderView, reducer as explorerReducer, thunkExtraArg as explorerThunkExtraArg, defaultTranslation as translationDict, useSettings, useTranslation };