import { ComponentPublicInstance, Ref, ComputedRef } from '../../node_modules/vue';
import { ChartData, LoadedData } from './useChartData';
export type { ChartData, LoadedData };
interface ChartEmit<T = Record<string, unknown>[] | Record<string, number>> {
    emit: {
        (event: 'resized'): void;
        (event: 'loaded', data: LoadedData<T>): void;
    };
}
interface ChartPropsDefinition {
    chartHeightRatio: {
        type: NumberConstructor;
    };
    data: {
        default: () => object[] | string;
        validator(value: string): boolean;
        type: (ArrayConstructor | StringConstructor | ObjectConstructor)[];
    };
    dataUrlType: {
        default: string;
        validator(value: string): boolean;
        type: StringConstructor;
    };
    socialMode: {
        type: BooleanConstructor;
    };
    socialModeRatio: {
        default: number;
        type: NumberConstructor;
    };
}
export interface ChartPropsRefs {
    chartHeightRatio: Ref<number | undefined>;
    data: Ref<ChartData>;
    dataUrlType: Ref<'json' | 'csv' | 'tsv'>;
    socialMode: Ref<boolean>;
    socialModeRatio: Ref<number>;
}
/**
 * Wraps a chart component's raw props into individual refs consumable by {@link useChart}.
 *
 * @param props - The chart component props (typically from `defineProps`).
 * @returns A {@link ChartPropsRefs} object exposing each chart prop as its own ref.
 * @remarks Internal building block consumed by {@link useChart}; not exported from the package root.
 * @example
 * // Inside a chart component, alongside chartProps() and useChart():
 * const props = defineProps(chartProps())
 * const chart = useChart(resizableRef, getChartProps(props), { emit }, isLoaded)
 */
export declare function getChartProps(props: {
    chartHeightRatio?: number;
    data?: ChartData;
    dataUrlType?: 'json' | 'csv' | 'tsv';
    socialMode?: boolean;
    socialModeRatio?: number;
}): ChartPropsRefs;
/**
 * Builds the shared Vue prop definitions every chart component accepts.
 *
 * @returns A {@link ChartPropsDefinition} object passable to `defineProps`.
 * @remarks Internal building block used by chart components together with {@link useChart}; not exported from the package root.
 * @example
 * // Inside a chart component's <script setup>:
 * const props = defineProps(chartProps())
 */
export declare const chartProps: () => ChartPropsDefinition;
export declare const chartEmits: string[];
export interface ElementsMaxBBoxOptions {
    selector?: string;
    defaultWidth?: number | null;
    defaultHeight?: number | null;
}
export interface ElementsMaxBBox {
    width: number | null | undefined;
    height: number | null | undefined;
}
export interface UseChartReturn<T = Record<string, unknown>[] | Record<string, number>> {
    dataHasHighlights: ComputedRef<boolean>;
    loadedData: Ref<LoadedData<T>>;
    mounted: Ref<boolean>;
    xAxisYearFormat: (year: number | string) => number | string;
    elementsMaxBBox: (options?: ElementsMaxBBoxOptions) => ElementsMaxBBox;
    d3Formatter: (value: number | string, formatter?: ((v: number | string) => string) | string) => string | number;
    baseHeightRatio: ComputedRef<number>;
}
/**
 * Powers a chart component: loads data (inline or from a URL), tracks size, and emits lifecycle events.
 *
 * @param resizableRef - Ref to the chart's resizable root element, observed for size changes.
 * @param props - The chart props as refs, typically produced by {@link getChartProps}.
 * @param context - The setup context providing `emit`, used to fire `loaded` and `resized`.
 * @param isLoaded - Ref flipped to `true` once data has finished loading; shared with the component.
 * @param onResized - Optional callback run after each settled resize and after the initial load.
 * @param afterLoaded - Optional async hook awaited after data loads but before `loaded` is emitted.
 * @returns A {@link UseChartReturn} with reactive state (`loadedData`, `mounted`, `dataHasHighlights`, `baseHeightRatio`) and helpers (`elementsMaxBBox`, `xAxisYearFormat`, `d3Formatter`).
 * @example
 * <script setup>
 * import { ref } from 'vue'
 * import { useChart } from '@icij/murmur-next'
 *
 * const resizableRef = ref()
 * const emit = defineEmits(['resized', 'loaded'])
 * const isLoaded = ref(false)
 * const chartProps = {
 *   data: ref([]),
 *   dataUrlType: ref('json'),
 *   chartHeightRatio: ref(undefined),
 *   socialMode: ref(false),
 *   socialModeRatio: ref(5 / 4)
 * }
 * const { loadedData, baseHeightRatio } = useChart(resizableRef, chartProps, { emit }, isLoaded)
 * </script>
 *
 * <template>
 *   <div ref="resizableRef">{{ loadedData }}</div>
 * </template>
 */
export declare function useChart<T = Record<string, unknown>[] | Record<string, number>>(resizableRef: Ref<ComponentPublicInstance<HTMLElement> | null>, props: ChartPropsRefs, { emit }: ChartEmit<T>, isLoaded: Ref<boolean>, onResized?: () => void, afterLoaded?: () => Promise<void>): UseChartReturn<T>;