/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2022 Samuel Gratzl <sam@sgratzl.com>
 */

import React from 'react';
import { ISets, ISetCombinations, ISetLike, UpSetQuery, NumericScaleLike, GenerateSetCombinationsOptions, ISet, ISetCombination, NumericScaleFactory, BandScaleFactory, UpSetQueries, IUpSetDump, IUpSetStaticDump } from '@upsetjs/model';
export * from '@upsetjs/model';

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

interface ITextLocation {
    text: {
        x: number;
        y: number;
    };
}
interface ICircle {
    r: number;
    cx: number;
    cy: number;
}
interface IEllipse {
    rx: number;
    ry: number;
    rotation: number;
    cx: number;
    cy: number;
}
interface ITextCircle extends ICircle, ITextLocation {
    align: 'start' | 'end' | 'middle';
    verticalAlign: 'top' | 'bottom';
}
interface ITextEllipse extends IEllipse, ITextLocation {
    align: 'start' | 'end' | 'middle';
    verticalAlign: 'top' | 'bottom';
}
interface IArc {
    x2: number;
    y2: number;
    sweep: boolean;
    large: boolean;
    ref: number;
    mode: 'i' | 'o';
}
interface IArcSlice {
    sets: readonly number[];
    x1: number;
    y1: number;
    arcs: readonly IArc[];
    path?: string;
}
interface ITextArcSlice extends IArcSlice, ITextLocation {
}
interface IUniverseSet extends IArcSlice {
    width: number;
    height: number;
}
interface ITextUniverseSet extends IUniverseSet, ITextLocation {
}
interface IVennDiagramLayoutGenerator {
    readonly maxSets: number;
    compute<T>(sets: ISets<T>, combinations: ISetCombinations<T>, width: number, height: number): IVennDiagramLayout;
}
interface IVennDiagramLayout {
    sets: (ITextCircle | ITextEllipse)[];
    universe?: ITextUniverseSet;
    intersections: ITextArcSlice[];
}
declare function isEllipse(d: ICircle | IEllipse): d is IEllipse;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

interface UpSetAddonProps<S extends ISetLike<T>, T> {
    /**
     * the current set to visualize
     */
    set: S;
    /**
     * the addon width
     */
    width: number;
    /**
     * the addon height
     */
    height: number;
    /**
     * the theme of the UpSetJS plot
     */
    theme: 'dark' | 'light' | 'vega';
}
declare type UpSetSelection<T> = ISetLike<T> | null | readonly T[] | ((s: ISetLike<T>) => number);
interface UpSetSelectionAddonProps<S extends ISetLike<T>, T> extends UpSetAddonProps<S, T> {
    /**
     * the current selection of the plot
     */
    selection: UpSetSelection<T>;
    /**
     * the specified selection color
     */
    selectionColor: string;
    /**
     * the optional overlap of the selection with the current set
     */
    overlap: readonly T[] | null;
}
interface UpSetQueryAddonProps<S extends ISetLike<T>, T> extends UpSetAddonProps<S, T> {
    /**
     * the current query to show
     */
    query: UpSetQuery<T>;
    /**
     * query index
     */
    index: number;
    /**
     * the optional overlap of the query with the current set
     */
    overlap: readonly T[] | null;
    /**
     * whether to render the query in secondary mode
     */
    secondary: boolean;
}
interface UpSetAddonHandlerInfo {
    readonly id: string;
    readonly name: string;
    readonly value: {
        toString(): void;
    };
}
declare type UpSetAddonHandlerInfos = readonly (UpSetAddonHandlerInfo | null)[];
interface UpSetAddon<S extends ISetLike<T>, T, N> {
    /**
     * addon name
     */
    name: string;
    /**
     * addon position before or after the bar
     * @default after
     */
    position?: 'before' | 'after';
    /**
     * size of this addon in pixel
     */
    size: number;
    /**
     * react component to render the addon
     */
    render: (props: UpSetAddonProps<S, T>) => N;
    /**
     * optional react component to render the selection
     */
    renderSelection?: (props: UpSetSelectionAddonProps<S, T>) => N;
    /**
     * optional react component to render a query
     */
    renderQuery?: (props: UpSetQueryAddonProps<S, T>) => N;
    createOnHandlerData?: (s: S) => UpSetAddonHandlerInfo;
    scale?: NumericScaleLike;
}
declare type UpSetAddons<S extends ISetLike<T>, T, N> = readonly UpSetAddon<S, T, N>[];
interface UpSetBaseFontSizes {
    /**
     * @default 16px
     */
    setLabel?: string;
    /**
     * @default 10px
     */
    legend?: string;
    /**
     * @default 24px
     */
    title?: string;
    /**
     * @default 16px
     */
    description?: string;
    /**
     * @default 10px
     */
    exportLabel?: string;
}
interface UpSetFontSizes extends UpSetBaseFontSizes {
    /**
     * @default 16px
     */
    chartLabel?: string;
    /**
     * @default 10px
     */
    axisTick?: string;
    /**
     * @default 10px
     */
    barLabel?: string;
}
interface VennDiagramFontSizes extends UpSetBaseFontSizes {
    /**
     * @default 12px
     */
    valueLabel?: string;
}
interface KarnaughMapFontSizes extends UpSetBaseFontSizes {
    /**
     * @default 10px
     */
    axisTick?: string;
    /**
     * @default 10px
     */
    barLabel?: string;
    /**
     * @default 16px
     */
    chartLabel?: string;
}
interface UpSetBaseMultiStyle<C> {
    setLabel?: C;
    legend?: C;
    title?: C;
    description?: C;
}
interface UpSetMultiStyle<C> extends UpSetBaseMultiStyle<C> {
    chartLabel?: C;
    axisTick?: C;
    barLabel?: C;
    bar?: C;
    dot?: C;
}
interface VennDiagramMultiStyle<C> extends UpSetBaseMultiStyle<C> {
    valueLabel?: C;
    set?: C;
}
interface KarnaughMapMultiStyle<C> extends UpSetBaseMultiStyle<C> {
    chartLabel?: C;
    axisTick?: C;
    barLabel?: C;
    bar?: C;
    set?: C;
}
interface UpSetBaseDataProps<T> {
    /**
     * the sets to visualize
     */
    sets: ISets<T>;
    /**
     * optional function to identify the same sets
     * @param set the set to generate a key for
     */
    toKey?: (set: ISetLike<T>) => string;
    /**
     * optional function to identify the same element
     * @param elem the element the key for
     */
    toElemKey?: (elem: T) => string;
}
interface UpSetDataProps<T, N> extends UpSetBaseDataProps<T> {
    /**
     * the set combinations to visualize or the generation options to generate the set combinations
     * by default all set intersections are computed
     */
    combinations?: ISetCombinations<T> | GenerateSetCombinationsOptions<T>;
    /**
     * list of addons that should be rendered along the horizontal sets
     */
    setAddons?: UpSetAddons<ISet<T>, T, N>;
    /**
     * list of addons that should be rendered along the vertical set combinations
     */
    combinationAddons?: UpSetAddons<ISetCombination<T>, T, N>;
    /**
     * padding between combination addons
     * @default 1
     */
    setAddonPadding?: number;
    /**
     * padding between combination addons
     * @default 1
     */
    combinationAddonPadding?: number;
    /**
     * numeric scale to use, either constants 'linear' or 'log' or a custom factory function
     * @default linear
     */
    numericScale?: NumericScaleFactory | 'linear' | 'log';
    /**
     * band scale to use, either constant 'band' or a custom factory function
     * @default band
     */
    bandScale?: BandScaleFactory | 'band';
    /**
     * maximum set scale value
     * @default derived from the sets
     */
    setMaxScale?: number;
    /**
     * maximum combination scale value
     * @default derived from the combinations
     */
    combinationMaxScale?: number;
}
interface VennDiagramDataProps<T> extends UpSetBaseDataProps<T> {
    /**
     * the set combinations to visualize or the generation options to generate the distinct set combinations
     * by default all set distinct intersections are computed
     */
    combinations?: ISetCombinations<T> | {
        /**
         * optional color merger
         **/
        mergeColors?: (colors: readonly (string | undefined)[]) => string | undefined;
    };
    valueFormat?: (cardinality: number) => string;
}
interface KarnaughMapDataProps<T> extends UpSetBaseDataProps<T> {
    /**
     * the set combinations to visualize or the generation options to generate the distinct set combinations
     * by default all set distinct intersections are computed
     */
    combinations?: ISetCombinations<T> | GenerateSetCombinationsOptions<T>;
    /**
     * numeric scale to use, either constants 'linear' or 'log' or a custom factory function
     * @default linear
     */
    numericScale?: NumericScaleFactory | 'linear' | 'log';
    /**
     * maximum combination scale value
     * @default derived from the combinations
     */
    combinationMaxScale?: number;
}
interface UpSetBaseLayoutProps {
    /**
     * width of the chart
     */
    width: number;
    /**
     * height of the chart
     */
    height: number;
    /**
     * padding within the svg
     * @default 5
     */
    padding?: number;
}
interface UpSetLayoutProps extends UpSetBaseLayoutProps {
    /**
     * padding argument for scaleBand
     * @default 0.1
     */
    barPadding?: number;
    /**
     * padding factor the for dots
     * @default 0.7
     */
    dotPadding?: number;
    /**
     * width ratios for different plots,
     * if a number larger than 1 is given, it is interpreted as pixel values
     * [set chart, set labels, intersection chart = derived]
     * @default [0.21, 0.19]
     */
    widthRatios?: [number, number];
    /**
     * height ratios for different plots,
     * if a number larger than 1 is given, it is interpreted as pixel values
     * [intersection chart, set chart = derived]
     * @default [0.6]
     */
    heightRatios?: [number];
    /**
     * alignment for the set labels
     * @default 'center'
     */
    setLabelAlignment?: 'left' | 'center' | 'right';
}
interface VennDiagramLayoutProps extends UpSetBaseLayoutProps {
    /**
     * function used to perform the venn diagram layout
     */
    layout?: IVennDiagramLayoutGenerator;
    /**
     * optional offsets for the x and y positions of each set label
     */
    setLabelOffsets?: readonly {
        x: number;
        y: number;
    }[];
}
interface KarnaughMapLayoutProps extends UpSetBaseLayoutProps {
    /**
     * padding argument for scaleBand
     * @default 0.1
     */
    barPadding?: number;
}
interface UpSetSelectionProps<T = any> {
    /**
     * the selection of the plot. Can be a set like (set or set combination), an array of elements, or a function to compute the overlap to a given set
     */
    selection?: UpSetSelection<T>;
    /**
     * mouse hover listener, triggered when the user is over a set (combination)
     * a combination of mouseEnter and mouseLeave
     */
    onHover?: (selection: ISetLike<T> | null, evt: MouseEvent, addonInfos: UpSetAddonHandlerInfos) => void;
    /**
     * mouse move over set listener, triggered when the user is over a set (combination)
     */
    onMouseMove?: (selection: ISetLike<T>, evt: MouseEvent, addonInfos: UpSetAddonHandlerInfos) => void;
    /**
     * mouse click listener, triggered when the user is clicking on a set (combination)
     */
    onClick?: (selection: ISetLike<T> | null, evt: MouseEvent, addonInfos: UpSetAddonHandlerInfos) => void;
    /**
     * mouse context menu listener, triggered when the user right clicks on a set (combination)
     */
    onContextMenu?: (selection: ISetLike<T> | null, evt: MouseEvent, addonInfos: UpSetAddonHandlerInfos) => void;
    /**
     * list of queries as an alternative to provide a single selection
     */
    queries?: UpSetQueries<T>;
}
interface UpSetBaseThemeProps {
    /**
     * color used to highlight the selection
     * @default orange
     */
    selectionColor?: string;
    /**
     * main color to render bars and dark dots
     * @default black
     */
    color?: string;
    /**
     * main opacity
     * @default undefined
     */
    opacity?: number;
    /**
     * main color used when a selection is present
     * @default undefined
     */
    hasSelectionColor?: string;
    /**
     * main opacity used when a selection is present
     * @default undefined
     */
    hasSelectionOpacity?: number;
    /**
     * main color to render text
     * @default black
     */
    textColor?: string;
}
interface UpSetThemeProps extends UpSetBaseThemeProps {
    /**
     * color used to highlight alternating background in the sets for easier comparison
     * set to false to disable alternating pattern
     */
    alternatingBackgroundColor?: string | false;
    /**
     * color for the hover hint rects for set combinations
     */
    hoverHintColor?: string;
    /**
     * color for dots that indicate it is not a member
     */
    notMemberColor?: string;
}
interface VennDiagramThemeProps extends UpSetBaseThemeProps {
    /**
     * main color to render text
     * @default black
     */
    valueTextColor?: string;
    /**
     * stroke color to render around sets or cells
     * @default black
     */
    strokeColor?: string;
    /**
     * whether to fill the circles
     * @default false
     */
    filled?: boolean;
}
interface KarnaughMapThemeProps extends UpSetBaseThemeProps {
    /**
     * stroke color to render around sets or cells
     * @default black
     */
    strokeColor?: string;
}
declare type UpSetStyleClassNames = UpSetMultiStyle<string>;
interface UpSetBaseElementProps<C, N> {
    /**
     * optional unique id of the set element. Note: if set, it is will also be used as a CSS class suffix
     */
    id?: string;
    /**
     * optional class name for the SVG element
     */
    className?: string;
    /**
     * style object applied to the SVG element
     */
    style?: C;
    /**
     * factory to create the style tag
     */
    styleFactory?: (rules: string) => N;
}
interface UpSetElementProps<T, C, N> extends UpSetBaseElementProps<C, N> {
    /**
     * object of classnames for certain sub elements
     */
    classNames?: UpSetStyleClassNames;
    /**
     * object for applying styles to certain sub elements
     */
    styles?: UpSetMultiStyle<C>;
    /**
     * factory to create extra react nodes for each set
     */
    setChildrenFactory?: (set: ISet<T>) => N;
    /**
     * factory to create extra react nodes for each set combination
     */
    combinationChildrenFactory?: (combination: ISetCombination<T>) => N;
}
interface VennDiagramElementProps<C, N> extends UpSetBaseElementProps<C, N> {
    /**
     * object of classnames for certain sub elements
     */
    classNames?: VennDiagramMultiStyle<string>;
    /**
     * object for applying styles to certain sub elements
     */
    styles?: VennDiagramMultiStyle<C>;
}
interface KarnaughMapElementProps<C, N> extends UpSetBaseElementProps<C, N> {
    /**
     * object of classnames for certain sub elements
     */
    classNames?: KarnaughMapMultiStyle<string>;
    /**
     * object for applying styles to certain sub elements
     */
    styles?: KarnaughMapMultiStyle<C>;
    /**
     * factory to create the style tag
     */
    styleFactory?: (rules: string) => N;
}
interface UpSetExportOptions {
    png?: boolean;
    svg?: boolean;
    vega?: boolean;
    dump?: boolean;
    share?: boolean;
}
declare type UpSetThemes = 'light' | 'dark' | 'vega';
interface UpSetBaseStyleProps<L> {
    /**
     * basic theme of the plot either 'light' or 'dark'
     * @default light
     */
    theme?: UpSetThemes;
    /**
     * show a legend of queries
     * enabled by default when queries are set
     */
    queryLegend?: boolean;
    /**
     * show export buttons
     * @default true
     */
    exportButtons?: boolean | UpSetExportOptions;
    /**
     * specify the overall font family, set to false to use the default font family
     * @default sans-serif
     */
    fontFamily?: string | false;
    /**
     * optional title text for the plot
     */
    title?: L;
    /**
     * optional description text for the plot
     */
    description?: L;
    /**
     * whether to render tooltips aka title attributes
     * @default true
     */
    tooltips?: boolean;
}
interface UpSetStyleProps<L> extends UpSetBaseStyleProps<L> {
    /**
     * offset of the label on top or left of a bar
     * @default 2
     */
    barLabelOffset?: number;
    /**
     * set axis label
     * @default Set Size
     */
    setName?: L;
    /**
     * offset of the set name from the set x axis. 'auto' means that it will be guessed according to the current values
     * @default auto
     */
    setNameAxisOffset?: number | 'auto';
    /**
     * combination axis label
     * @default Intersection Size
     */
    combinationName?: L;
    /**
     * offset of the combination name from the combination y axis. 'auto' means that it will be guessed according to the current values
     * @default auto
     */
    combinationNameAxisOffset?: number | 'auto';
    /**
     * specify font sizes for different sub elements
     */
    fontSizes?: UpSetFontSizes;
    /**
     * render empty selection for better performance
     * @default true
     */
    emptySelection?: boolean;
}
interface VennDiagramStyleProps<L> extends UpSetBaseStyleProps<L> {
    /**
     * specify font sizes for different sub elements
     */
    fontSizes?: VennDiagramFontSizes;
}
interface KarnaughMapStyleProps<L> extends UpSetBaseStyleProps<L> {
    /**
     * specify font sizes for different sub elements
     */
    fontSizes?: KarnaughMapFontSizes;
    /**
     * render empty selection for better performance
     * @default true
     */
    emptySelection?: boolean;
    /**
     * offset of the label on top or left of a bar
     * @default 2
     */
    barLabelOffset?: number;
    /**
     * combination axis label
     * @default Intersection Size
     */
    combinationName?: L;
    /**
     * offset of the combination name from the combination y axis. 'auto' means that it will be guessed according to the current values
     * @default auto
     */
    combinationNameAxisOffset?: number | 'auto';
}
/**
 * the UpSetJS component properties, separated in multiple semantic sub interfaces
 */
interface UpSetPropsG<T, C, N, L> extends UpSetDataProps<T, N>, UpSetLayoutProps, UpSetStyleProps<L>, UpSetThemeProps, UpSetElementProps<T, C, N>, UpSetSelectionProps<T> {
    children?: N;
}
declare type UpSetProps<T = any> = UpSetPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>;
interface UpSetFullPropsG<T, C, N, L> extends Required<Omit<UpSetDataProps<T, N>, 'toElemKey'>>, Required<UpSetLayoutProps>, Required<UpSetStyleProps<L>>, Required<UpSetThemeProps>, Required<UpSetElementProps<T, C, N>>, UpSetSelectionProps<T> {
    children?: N;
    toElemKey?: (elem: T) => string;
}
declare type UpSetFullProps<T = any> = UpSetFullPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>;
interface VennDiagramPropsG<T, C, N, L> extends VennDiagramDataProps<T>, VennDiagramLayoutProps, VennDiagramStyleProps<L>, VennDiagramThemeProps, VennDiagramElementProps<C, N>, UpSetSelectionProps<T> {
    children?: N;
}
declare type VennDiagramProps<T = any> = VennDiagramPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>;
interface VennDiagramFullPropsG<T, C, N, L> extends Required<Omit<VennDiagramDataProps<T>, 'toElemKey'>>, Required<VennDiagramLayoutProps>, Required<VennDiagramStyleProps<L>>, Required<VennDiagramThemeProps>, Required<VennDiagramElementProps<C, N>>, UpSetSelectionProps<T> {
    toElemKey?: (elem: T) => string;
    children?: N;
}
declare type VennDiagramFullProps<T = any> = VennDiagramFullPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>;
interface KarnaughMapPropsG<T, C, N, L> extends KarnaughMapDataProps<T>, KarnaughMapLayoutProps, KarnaughMapStyleProps<L>, KarnaughMapThemeProps, KarnaughMapElementProps<C, N>, UpSetSelectionProps<T> {
    children?: N;
}
declare type KarnaughMapProps<T = any> = KarnaughMapPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>;
interface KarnaughMapFullPropsG<T, C, N, L> extends Required<Omit<KarnaughMapDataProps<T>, 'toElemKey'>>, Required<KarnaughMapLayoutProps>, Required<KarnaughMapStyleProps<L>>, Required<KarnaughMapThemeProps>, Required<KarnaughMapElementProps<C, N>>, UpSetSelectionProps<T> {
    toElemKey?: (elem: T) => string;
    children?: N;
}
declare type KarnaughMapFullProps<T = any> = KarnaughMapFullPropsG<T, React.CSSProperties, React.ReactNode, React.ReactNode>;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

declare const _default$2: <T>(p: UpSetProps<T> & React.RefAttributes<SVGSVGElement>) => React.ReactElement;

declare const _default$1: <T>(p: VennDiagramProps<T> & React.RefAttributes<SVGSVGElement>) => React.ReactElement;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

declare const _default: <T>(p: KarnaughMapProps<T> & React.RefAttributes<SVGSVGElement>) => React.ReactElement;

/**
 * helper method to export an download an SVG image
 * @param node the SVG element to download
 * @param options additional options
 */
declare function exportSVG(node: SVGSVGElement, { type, title, toRemove }: {
    type?: 'png' | 'svg';
    title?: string;
    toRemove?: string;
}): Promise<void>;
/**
 * helper method to download a given url in the browser
 * @param url the url to download
 * @param title the desired file name
 * @param doc the root document
 */
declare function downloadUrl(url: string, title: string, doc: Document): void;

declare function exportVegaLite(svg: SVGSVGElement, { title }?: {
    title?: string;
}): void;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

declare type UpSetExtraTheme = {
    backgroundColor: string;
};
declare function getDefaultTheme(theme?: UpSetThemes): Readonly<Required<UpSetThemeProps & VennDiagramThemeProps & UpSetExtraTheme>>;
/**
 * helper methods to fill up partial UpSet.js properties with their default values
 */
declare function fillDefaultsG<T, C, N, L = N>(props: UpSetPropsG<T, C, N, L>): UpSetFullPropsG<T, C, N, L>;
declare function fillDefaults<T = any>(props: UpSetProps<T>): UpSetFullProps<T>;
/**
 * helper methods to fill up partial UpSet.js properties with their default values
 */
declare function fillVennDiagramDefaultsG<T, C, N, L = N>(props: VennDiagramPropsG<T, C, N, L>): VennDiagramFullPropsG<T, C, N, L>;
declare function fillVennDiagramDefaults<T = any>(props: VennDiagramProps<T>): VennDiagramFullProps<T>;
/**
 * helper methods to fill up partial UpSet.js properties with their default values
 */
declare function fillKarnaughMapDefaultsG<T, C, N, L = N>(props: KarnaughMapPropsG<T, C, N, L>): KarnaughMapFullPropsG<T, C, N, L>;
declare function fillKarnaughMapDefaults<T = any>(props: KarnaughMapProps<T>): KarnaughMapFullProps<T>;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

interface UpSetJSDumpProps extends Partial<UpSetLayoutProps & KarnaughMapLayoutProps>, UpSetThemeProps, VennDiagramThemeProps, KarnaughMapThemeProps, Omit<UpSetStyleProps<string>, 'title' | 'description'> {
    numericScale?: 'linear' | 'log';
    bandScale?: 'band';
}
interface IUpSetJSDump extends IUpSetDump {
    $schema: string;
    name: string;
    description: string;
    author?: string;
    mode?: 'upset' | 'venn' | 'kmap';
    elements: readonly (number | string | any)[];
    attrs: readonly string[];
    props: UpSetJSDumpProps;
}
declare function toUpSetJSDump(dump: IUpSetDump, elements: readonly (number | string | any)[], props: Partial<UpSetProps<any> & VennDiagramProps<any> & KarnaughMapProps<any>>, author?: string, mode?: 'venn' | 'kmap' | 'upset'): IUpSetJSDump;
interface IUpSetJSStaticDump extends IUpSetStaticDump {
    $schema: string;
    name: string;
    description: string;
    author?: string;
    props: UpSetJSDumpProps;
    mode?: 'upset' | 'venn' | 'kmap';
}
declare function toUpSetJSStaticDump(dump: IUpSetStaticDump, props: Partial<UpSetProps<any> & VennDiagramProps<any> & KarnaughMapProps<any>>, author?: string, mode?: 'venn' | 'kmap' | 'upset'): IUpSetJSStaticDump;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

interface UpSetJSSkeletonProps extends React.SVGAttributes<SVGSVGElement> {
    background?: string;
    color?: string;
    secondaryColor?: string;
}
/**
 * UpSetJS Skeleton a simple UpSetJS skeleton
 *
 * with React.forwardRef support to specify a reference to the SVG element
 */
declare const UpSetJSSkeleton: React.FC<UpSetJSSkeletonProps & React.RefAttributes<SVGSVGElement>>;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

/**
 * VennDiagram Skeleton a simple VennDiagram skeleton
 *
 * with React.forwardRef support to specify a reference to the SVG element
 */
declare const VennDiagramSkeleton: React.FC<UpSetJSSkeletonProps & React.RefAttributes<SVGSVGElement>>;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

/**
 * KV Diagram Skeleton a simple KarnaughMap skeleton
 *
 * with React.forwardRef support to specify a reference to the SVG element
 */
declare const KarnaughMapSkeleton: React.FC<UpSetJSSkeletonProps & React.RefAttributes<SVGSVGElement>>;

/**
 * @upsetjs/react
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

interface IVennJSSetOverlap {
    sets: readonly string[];
    size: number;
    weight?: number;
}
interface IVennJSArc {
    circle: {
        x: number;
        y: number;
        radius: number;
    };
    width: number;
    p1: {
        x: number;
        y: number;
    };
    p2: {
        x: number;
        y: number;
    };
}
interface IVennJSVennLayout {
    data: IVennJSSetOverlap;
    text: {
        x: number;
        y: number;
    };
    circles: readonly {
        x: number;
        y: number;
        radius: number;
        set: string;
    }[];
    arcs: readonly IVennJSArc[];
    path?: string;
    distinctPath?: string;
}
interface IVennJSLayoutFunction<O extends {
    width?: number;
    height?: number;
    distinct?: boolean;
}> {
    (data: readonly IVennJSSetOverlap[], options: O): readonly IVennJSVennLayout[];
}
declare function createVennJSAdapter<O extends {
    width?: number;
    height?: number;
}>(layout: IVennJSLayoutFunction<O>, options?: O): IVennDiagramLayoutGenerator;

/**
 * @upsetjs/bundle
 * https://github.com/upsetjs/upsetjs
 *
 * Copyright (c) 2021 Samuel Gratzl <sam@sgratzl.com>
 */

declare function widthRatios(value?: UpSetLayoutProps['widthRatios']): boolean;
declare function heightRatios(value?: UpSetLayoutProps['heightRatios']): boolean;
declare function setLabelAlignment(value?: UpSetLayoutProps['setLabelAlignment']): boolean;
declare function sets(value: UpSetBaseDataProps<any>['sets']): boolean;
declare function combinations(value?: UpSetDataProps<any, any>['combinations']): boolean;
declare function selection(value?: UpSetSelectionProps<any>['selection']): boolean;
declare function onHover(value?: UpSetSelectionProps<any>['onHover']): boolean;
declare function onClick(value?: UpSetSelectionProps<any>['onClick']): boolean;
declare function onContextMenu(value?: UpSetSelectionProps<any>['onContextMenu']): boolean;
declare function onMouseMove(value?: UpSetSelectionProps<any>['onMouseMove']): boolean;
declare function queries(value?: UpSetSelectionProps<any>['queries']): boolean;
declare function stringOrFalse(value?: string | false): boolean;
declare function setLabelOffsets(value?: VennDiagramLayoutProps['setLabelOffsets']): boolean;
declare function theme(value?: UpSetThemes): boolean;
declare function classNames(value?: UpSetStyleClassNames | VennDiagramMultiStyle<string> | KarnaughMapMultiStyle<string>): boolean;
declare function fontSizes(value?: UpSetFontSizes | VennDiagramFontSizes | KarnaughMapFontSizes): boolean;
declare function numericScale(value?: UpSetDataProps<any, any>['numericScale']): boolean;
declare function bandScale(value?: UpSetDataProps<any, any>['bandScale']): boolean;
declare function axisOffset(value?: UpSetStyleProps<any>['setNameAxisOffset']): boolean;
declare function style(value?: any): boolean;
declare function styles(value?: UpSetMultiStyle<any> | VennDiagramMultiStyle<any> | KarnaughMapMultiStyle<any>): boolean;
declare function exportButtons(value?: UpSetBaseStyleProps<any>['exportButtons']): boolean;

declare const validators_widthRatios: typeof widthRatios;
declare const validators_heightRatios: typeof heightRatios;
declare const validators_setLabelAlignment: typeof setLabelAlignment;
declare const validators_sets: typeof sets;
declare const validators_combinations: typeof combinations;
declare const validators_selection: typeof selection;
declare const validators_onHover: typeof onHover;
declare const validators_onClick: typeof onClick;
declare const validators_onContextMenu: typeof onContextMenu;
declare const validators_onMouseMove: typeof onMouseMove;
declare const validators_queries: typeof queries;
declare const validators_stringOrFalse: typeof stringOrFalse;
declare const validators_setLabelOffsets: typeof setLabelOffsets;
declare const validators_theme: typeof theme;
declare const validators_classNames: typeof classNames;
declare const validators_fontSizes: typeof fontSizes;
declare const validators_numericScale: typeof numericScale;
declare const validators_bandScale: typeof bandScale;
declare const validators_axisOffset: typeof axisOffset;
declare const validators_style: typeof style;
declare const validators_styles: typeof styles;
declare const validators_exportButtons: typeof exportButtons;
declare namespace validators {
  export {
    validators_widthRatios as widthRatios,
    validators_heightRatios as heightRatios,
    validators_setLabelAlignment as setLabelAlignment,
    validators_sets as sets,
    validators_combinations as combinations,
    validators_selection as selection,
    validators_onHover as onHover,
    validators_onClick as onClick,
    validators_onContextMenu as onContextMenu,
    validators_onMouseMove as onMouseMove,
    validators_queries as queries,
    validators_stringOrFalse as stringOrFalse,
    validators_setLabelOffsets as setLabelOffsets,
    validators_theme as theme,
    validators_classNames as classNames,
    validators_fontSizes as fontSizes,
    validators_numericScale as numericScale,
    validators_bandScale as bandScale,
    validators_axisOffset as axisOffset,
    validators_style as style,
    validators_styles as styles,
    validators_exportButtons as exportButtons,
  };
}

export { IArc, IArcSlice, ICircle, IEllipse, ITextArcSlice, ITextCircle, ITextEllipse, ITextLocation, ITextUniverseSet, IUniverseSet, IUpSetJSDump, IUpSetJSStaticDump, IVennDiagramLayout, IVennDiagramLayoutGenerator, _default as KarnaughMap, KarnaughMapDataProps, KarnaughMapElementProps, KarnaughMapFontSizes, KarnaughMapFullProps, KarnaughMapFullPropsG, KarnaughMapLayoutProps, KarnaughMapMultiStyle, KarnaughMapProps, KarnaughMapPropsG, KarnaughMapSkeleton, KarnaughMapStyleProps, KarnaughMapThemeProps, UpSetAddon, UpSetAddonHandlerInfo, UpSetAddonHandlerInfos, UpSetAddonProps, UpSetAddons, UpSetBaseDataProps, UpSetBaseElementProps, UpSetBaseFontSizes, UpSetBaseLayoutProps, UpSetBaseMultiStyle, UpSetBaseStyleProps, UpSetBaseThemeProps, UpSetDataProps, UpSetElementProps, UpSetExportOptions, UpSetExtraTheme, UpSetFontSizes, UpSetFullProps, UpSetFullPropsG, _default$2 as UpSetJS, UpSetJSDumpProps, UpSetJSSkeleton, UpSetJSSkeletonProps, UpSetLayoutProps, UpSetMultiStyle, UpSetProps, UpSetPropsG, UpSetQueryAddonProps, UpSetSelection, UpSetSelectionAddonProps, UpSetSelectionProps, UpSetStyleClassNames, UpSetStyleProps, UpSetThemeProps, UpSetThemes, _default$1 as VennDiagram, VennDiagramDataProps, VennDiagramElementProps, VennDiagramFontSizes, VennDiagramFullProps, VennDiagramFullPropsG, VennDiagramLayoutProps, VennDiagramMultiStyle, VennDiagramProps, VennDiagramPropsG, VennDiagramSkeleton, VennDiagramStyleProps, VennDiagramThemeProps, createVennJSAdapter, _default$2 as default, downloadUrl, exportSVG, exportVegaLite, fillDefaults, fillDefaultsG, fillKarnaughMapDefaults, fillKarnaughMapDefaultsG, fillVennDiagramDefaults, fillVennDiagramDefaultsG, getDefaultTheme, isEllipse, validators as propValidators, toUpSetJSDump, toUpSetJSStaticDump };
//# sourceMappingURL=index.d.ts.map