/// <reference types="react" />
import * as react_jsx_runtime from 'react/jsx-runtime';
import React$1 from 'react';

declare const ExperienceProvider: ({ children, }: {
    children: React$1.ReactNode;
}) => react_jsx_runtime.JSX.Element;

interface FontFaceProp {
    key: string;
    value: string;
}

interface FontFace {
    fontFamily: string;
    srcUrl?: string;
    extraProps?: FontFaceProp[];
}

type GetRequiredProperty<Type, Key extends keyof Type> = {
  [Property in Key]-?: Type[Property];
};

type GetOptionalProperty<Type, Key extends keyof Type> = Partial<{
  [Property in Key]: Type[Property];
}>;

/**
 * Merge types
 */
type MergeType<T> = Pick<T, keyof T>;

/**
 * Test if types are the same
 */
type Same$1<T1, T2> = T1 extends T2 ? true : false;
/**
 * Test if unions / types overlap
 */
type Overlap$1<T1, T2> = Same$1<T1, T2> extends false ? Extract<T1, T2> extends never ? false : true : true;
/**
 * Get the properties, required and optional
 *
 * @typeParam TSource - Source Type/Interface
 * @typeParam RequiredProperties - required properties in current context. Must be properties of TSource.
 * @typeParam OptionalProperties - optional properties in current context. Must be properties of TSource.
 */
type GetProps$1<TSource, RequiredProperties extends keyof TSource | null, OptionalProperties extends keyof TSource | null> = Overlap$1<RequiredProperties, OptionalProperties> extends true ? never : MergeType<Omit<TSource, Exclude<RequiredProperties | OptionalProperties, null>> & GetRequiredProperty<TSource, Exclude<RequiredProperties, null>> & GetOptionalProperty<TSource, Exclude<OptionalProperties, null>>>;
/**
 * Check if given tags are valid
 */
type FilterElements$1<T extends React.ElementType> = T;
/**
 * Polymorphic properties: Add an "as" property to define the tagname
 */
type AsProp$1<C> = {
    as?: C;
};
/**
 * Remove duplicate keys from combined types
 */
type PropsToOmit$1<C extends React.ElementType, P> = keyof (AsProp$1<C> & P);
/**
 * Set polymorphic component properties (only when required!)
 *
 * @typeParam C - Define the element type (tag)
 * @typeParam Props - Non polymorphic properties for component
 */
type PolymorphicComponentProp$1<C extends React.ElementType, Props = object> = MergeType<React.PropsWithChildren<Props & AsProp$1<C>> & Omit<React.ComponentPropsWithoutRef<C>, PropsToOmit$1<C, Props>>>;

/**
 * Test if types are the same
 */
type Same<T1, T2> = T1 extends T2 ? true : false;

/**
 * Test if unions / types overlap
 */
type Overlap<T1, T2> = Same<T1, T2> extends false
  ? Extract<T1, T2> extends never
    ? false
    : true
  : true;

/**
 * Get the properties, required and optional
 *
 * @typeParam TSource - Source Type/Interface
 * @typeParam RequiredProperties - required properties in current context. Must be properties of TSource.
 * @typeParam OptionalProperties - optional properties in current context. Must be properties of TSource.
 */
type GetProps<
  TSource,
  RequiredProperties extends keyof TSource | null,
  OptionalProperties extends keyof TSource | null,
> = Overlap<RequiredProperties, OptionalProperties> extends true
  ? never
  : MergeType<
      Omit<TSource, Exclude<RequiredProperties | OptionalProperties, null>> &
        GetRequiredProperty<TSource, Exclude<RequiredProperties, null>> &
        GetOptionalProperty<TSource, Exclude<OptionalProperties, null>>
    >;

/**
 * Check if given tags are valid
 */
type FilterElements<T extends React.ElementType> = T;

/**
 * Polymorphic properties: Add an "as" property to define the tagname
 */
type AsProp<C> = {
  as?: C;
};

/**
 * Remove duplicate keys from combined types
 */
type PropsToOmit<C extends React.ElementType, P> = keyof (AsProp<C> & P);

/**
 * Set polymorphic component properties (only when required!)
 *
 * @typeParam C - Define the element type (tag)
 * @typeParam Props - Non polymorphic properties for component
 */
type PolymorphicComponentProp<
  C extends React.ElementType,
  Props = object,
> = MergeType<
  React.PropsWithChildren<Props & AsProp<C>> &
    Omit<React.ComponentPropsWithoutRef<C>, PropsToOmit<C, Props>>
>;

declare const colorPalettes = <const>[
  'white',
  'primary',
  'secondary',
  'tertiary',
];

type ColorPalettesDefaults = typeof colorPalettes;
type ColorPaletteDefault = ColorPalettesDefaults[number];
type GetColorPalette<T extends ColorPaletteDefault> = T;

type ButtonColorPalette$1 = GetColorPalette<
  'primary' | 'secondary' | 'tertiary'
>;

type ButtonElements$1 = FilterElements<'button'>;

type ButtonProps$1<C extends ButtonElements$1> = PolymorphicComponentProp<
  C,
  {
    color?: ButtonColorPalette$1;
    disabled?: boolean;
    isLoading?: boolean;
  }
>;

type ContentType = string | 'html' | React.ReactNode;
type Content<CONTENT_TYPE = ContentType, FORMAT_TYPE = 'string'> = {
  value: CONTENT_TYPE;
  renderType: FORMAT_TYPE;
};
type InternalProps<T extends React.ElementType> = Omit<
  React.ComponentPropsWithoutRef<T>,
  'children'
>;

type DummyAdvancedProps<T extends React.ElementType = 'div'> = {
    dummyTitle: {
        content: Content<string>;
    };
    dummyText: {
        props?: InternalProps<'p'>;
        content: Content<React.ReactNode>;
    };
    dummyButton: {
        props?: Omit<InternalProps<'button'> & ButtonProps$1<'button'>, 'children'>;
        content: Content<string>;
    };
} & React.ComponentPropsWithoutRef<T>;

declare const DummyAdvanced: ({ children, dummyTitle, dummyText, dummyButton, ...props }: DummyAdvancedProps<'div'>) => react_jsx_runtime.JSX.Element;

type DummyNoDepsProps<T extends React.ElementType = 'div'> = {
    dummyTitle: {
        content: Content<string>;
    };
    dummyText: {
        props?: InternalProps<'p'>;
        content: Content<React.ReactNode>;
    };
    dummyButton: {
        props?: Omit<InternalProps<'button'>, 'children'>;
        content: Content<string>;
    };
} & React.ComponentPropsWithoutRef<T>;

declare const DummyNoDeps: ({ children, dummyTitle, dummyButton, dummyText, ...props }: DummyNoDepsProps) => react_jsx_runtime.JSX.Element;

type DummySimpleProps = ButtonProps$1<'button'>;

declare const DummySimple: ({ children, ...props }: DummySimpleProps) => react_jsx_runtime.JSX.Element;

type DummyTextColor = GetColorPalette<'primary' | 'secondary' | 'tertiary'>;
declare const dummyTextSizes: {
    readonly sm: "2rem";
    readonly md: "3rem";
    readonly lg: "5rem";
};
type DummyTextSizes = typeof dummyTextSizes;
type DummyTextSize = keyof DummyTextSizes;
type DummyTextOwnProps<E extends React$1.ElementType> = {
    size?: DummyTextSize;
    color?: DummyTextColor;
    children: React$1.ReactNode;
    as?: E;
};
type DummyTextProps<E extends React$1.ElementType> = DummyTextOwnProps<E> & Omit<React$1.ComponentProps<E>, keyof DummyTextOwnProps<E>>;

declare const DummyText: <E extends React$1.ElementType<any>>({ size, children, as, ...props }: DummyTextProps<E>) => react_jsx_runtime.JSX.Element;

type ButtonColorPalette = GetColorPalette<'primary' | 'secondary' | 'tertiary'>;
type ButtonElements = FilterElements<'button'>;
type ButtonProps<C extends ButtonElements> = PolymorphicComponentProp<C, {
    color?: ButtonColorPalette;
    disabled?: boolean;
    isLoading?: boolean;
}>;

declare const Button: ({ children, className, disabled, isLoading, onClick, ...props }: ButtonProps<'button'>) => react_jsx_runtime.JSX.Element;

type DividerProps$1<C extends 'div' = 'div'> = PolymorphicComponentProp<C, {
    text: string;
}>;

declare const Divider: ({ text, ...props }: DividerProps$1) => react_jsx_runtime.JSX.Element;

type BoxColorPalette = GetColorPalette<'white' | 'secondary' | 'tertiary'>;
type BoxElements = FilterElements<'div' | 'section' | 'aside' | 'header' | 'nav' | 'footer' | 'article'>;
type BoxProps<C extends BoxElements> = PolymorphicComponentProp<C, {
    color?: BoxColorPalette;
}>;

declare const Box: <C extends "article" | "aside" | "div" | "footer" | "header" | "nav" | "section">({ as, children, className, color, ...props }: BoxProps<C>) => react_jsx_runtime.JSX.Element;

declare const ProgressBar: ({ progressProps, className, ...props }: ProgressBarProps) => react_jsx_runtime.JSX.Element;

type ProgressBarProps<T extends React.ElementType = 'div'> = React.ComponentPropsWithoutRef<T> & {
    progressProps: {
        value: number;
        max?: number;
    };
};

declare const ShowMore: <C extends "div" = "div">({ button, color, className, divider, progress, ...props }: ShowMoreProps<C>) => react_jsx_runtime.JSX.Element;

type DividerProps<C extends 'div' = 'div'> = PolymorphicComponentProp<
  C,
  {
    text: string;
  }
>;

type ShowMoreColorPaletteProps = GetColorPalette<'white' | 'tertiary'>;
type ShowMoreElements = FilterElements<'div'>;
type ShowMoreProps<C extends ShowMoreElements> = PolymorphicComponentProp<C, {
    color: ShowMoreColorPaletteProps;
    className?: string;
    button: MergeType<GetProps<ButtonProps$1<'button'> & {
        text: string;
    }, 'onClick' | 'aria-label', null>>;
    divider: DividerProps<'div'>;
    progress: {
        value: number;
    };
}>;

declare const Container: ({ children, ...props }: ContainerProps) => react_jsx_runtime.JSX.Element;

type ContainerProps<T extends React.ElementType = 'div'> = React.ComponentPropsWithoutRef<T>;

declare const Loader: ({ className, ...props }: LoaderProps<'span'>) => react_jsx_runtime.JSX.Element;

type LoaderProps<C extends 'span' = 'span'> = PolymorphicComponentProp<C>;

export { Box, type BoxColorPalette, type BoxProps, Button, type ButtonProps, Container, type ContainerProps, Divider, type DividerProps$1 as DividerProps, DummyAdvanced, type DummyAdvancedProps, DummyNoDeps, type DummyNoDepsProps, DummySimple, type DummySimpleProps, DummyText, type DummyTextProps, ExperienceProvider, type FilterElements$1 as FilterElements, type FontFace, type FontFaceProp, type GetProps$1 as GetProps, Loader, type LoaderProps, type PolymorphicComponentProp$1 as PolymorphicComponentProp, ProgressBar, type ProgressBarProps, type Same$1 as Same, ShowMore, type ShowMoreColorPaletteProps as ShowMoreColorPalette, type ShowMoreProps };