import * as lit from 'lit';
import { LitElement, PropertyValues } from 'lit';
import * as twind from 'twind';
import { nothing } from 'lit/html.js';
import { Instance } from '@dblechoc/tippy.js';

declare const validElementTagNames: readonly ["a", "abbr", "address", "applet", "area", "article", "aside", "audio", "b", "base", "basefont", "bdi", "bdo", "blockquote", "body", "br", "button", "canvas", "caption", "cite", "code", "col", "colgroup", "data", "datalist", "dd", "del", "details", "dfn", "dialog", "dir", "div", "dl", "dt", "em", "embed", "fieldset", "figcaption", "figure", "font", "footer", "form", "frame", "frameset", "h1", "h2", "h3", "h4", "h5", "h6", "head", "header", "hgroup", "hr", "html", "i", "iframe", "img", "input", "ins", "kbd", "label", "legend", "li", "link", "main", "map", "mark", "marquee", "menu", "meta", "meter", "nav", "noscript", "object", "ol", "optgroup", "option", "output", "p", "param", "picture", "pre", "progress", "q", "rp", "rt", "ruby", "s", "samp", "script", "section", "select", "slot", "small", "source", "span", "strong", "style", "sub", "summary", "sup", "table", "tbody", "td", "template", "textarea", "tfoot", "th", "thead", "time", "title", "tr", "track", "u", "ul", "var", "video", "wbr"];
declare type ElementTagName = typeof validElementTagNames[number];

declare type Tone = 'highlight-1' | 'highlight-1-dark' | 'highlight-1-darker' | 'highlight-2' | 'highlight-2-dark' | 'highlight-2-darker' | 'highlight-3' | 'highlight-3-dark' | 'highlight-3-darker' | 'highlight-4' | 'highlight-4-dark' | 'highlight-4-darker' | 'neutral-1' | 'neutral-2' | 'neutral-3' | 'neutral-4' | 'neutral-5' | 'neutral-6' | 'neutral-7' | 'alert' | 'alert-light' | 'success' | 'success-light' | 'white';
declare type InputTone = 'primary' | 'accent' | 'highlight' | 'dark' | 'white';
declare type Space = 'none' | '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'gutter' | 'xl' | '2xl';
declare type AlignX = 'stretch' | 'left' | 'right' | 'center';
declare type AlignY = 'top' | 'bottom' | 'center';
declare type TextAlign = 'left' | 'right' | 'center' | 'justify';
declare type ResponsiveBreakpoint = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
declare type FontWeigth = 'thin' | 'extralight' | 'light' | 'normal' | 'medium' | 'semibold' | 'bold' | 'extrabold' | 'black';
declare type LetterSpacing = 'tighter' | 'tight' | 'normal' | 'wide' | 'wider' | 'widest';
declare type RoundedCorners = 'none' | 'rounded';

interface Hideable {
    isHidden(): boolean;
}

declare type FontSize = 'xs' | 'sm' | 'base' | 'lg' | 'xl' | '2xl' | '2.5xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | '8xl' | '9xl' | 'heading-1' | 'heading-1-big' | 'heading-2' | 'heading-2-big' | 'heading-3' | 'heading-3-big' | 'heading-4' | 'heading-4-big' | 'heading-5' | 'heading-5-big' | 'heading-6' | 'heading-6-big';
declare type FontFamily = 'sans' | 'serif' | 'mono' | 'feature';

declare type IconName = 'menu' | 'phone' | 'user' | 'pencil-alt' | 'help-bubble' | 'ambulance' | 'tick';
declare class MonoIconComp extends LitElement {
    private __spreadController;
    private __stylesController;
    as: ElementTagName;
    iconName: IconName;
    size: number;
    strokeWidth: number;
    private __getSvgIcon;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-icon': MonoIconComp;
    }
}

declare const validStackElementTagNames: readonly ["div", "ol", "ul"];
declare type StackElementTagName = typeof validStackElementTagNames[number];
declare class MonoStackComp extends LitElement {
    private __spreadController;
    private __stylesController;
    private __uniqueSlotController;
    as: StackElementTagName;
    space: Space;
    alignX: AlignX;
    __hiddenIndexes: Set<number>;
    private __computeSpaceY;
    private __computeAlignX;
    private __includesHideable;
    private __handleResize;
    private __onHideableEvent;
    private __onSlotChange;
    private __renderChildren;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-stack': MonoStackComp;
    }
}

declare type ButtonSize = 'sm' | 'base' | 'lg';
declare type ButtonVariant = 'solid' | 'ghost';
declare const validButtonElementTagNames: readonly ["button", "a"];
declare type ButtonElementTagName = typeof validButtonElementTagNames[number];
declare class MonoButtonComp extends LitElement {
    private __spreadController;
    private __stylesController;
    as: ButtonElementTagName;
    tone: InputTone;
    size: ButtonSize;
    variant: ButtonVariant;
    corners: RoundedCorners;
    disabled: boolean;
    loading: boolean;
    submit: boolean;
    insetsX: number;
    __buttonEl: HTMLButtonElement;
    constructor();
    private __computePaddingYForSize;
    private __computeFontForSize;
    private __computeStyleForToneAndVariant;
    private __computeInsetsX;
    private __onClick;
    private __renderContent;
    private __renderLoadingContent;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-button': MonoButtonComp;
    }
}

declare type ColumnWidth = 'auto' | 'content' | '1/2' | '1/3' | '2/3' | '1/4' | '3/4' | '1/5' | '2/5' | '3/5' | '4/5';
declare class MonoColumnComp extends LitElement {
    width: ColumnWidth;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-column': MonoColumnComp;
    }
}

declare type HeadingLevel = '1' | '2' | '3' | '4' | '5' | '6';
declare class MonoHeadingComp extends LitElement {
    private __spreadController;
    private __stylesController;
    as: ElementTagName;
    level: HeadingLevel;
    weight: FontWeigth;
    alignText?: TextAlign;
    truncate: boolean;
    private __computTextSizeForLevel;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-heading': MonoHeadingComp;
    }
}

declare const validCardElementTagNames: readonly ["article", "aside", "details", "div", "main", "section"];
declare type CardElementTagName = typeof validCardElementTagNames[number];
declare class MonoCardComp extends LitElement {
    private __spreadController;
    private __stylesController;
    private __uniqueSlotController;
    as: CardElementTagName;
    rounded: boolean;
    roundedAbove?: ResponsiveBreakpoint;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-card': MonoCardComp;
    }
}

declare class MonoTextComp extends LitElement {
    static styles: lit.CSSResultGroup;
    private __spreadController;
    private __stylesController;
    as: ElementTagName;
    size?: FontSize;
    family?: FontFamily;
    weight?: FontWeigth;
    tracking?: LetterSpacing;
    tone?: Tone;
    alignText?: TextAlign;
    inline: boolean;
    truncate: boolean;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-text': MonoTextComp;
    }
}

declare type SelectOption = {
    selected?: boolean;
    disabled?: boolean;
    hidden?: boolean;
    value: string;
    text: string;
};
declare class MonoSelectComp extends LitElement {
    static styles: lit.CSSResultGroup;
    private __spreadController;
    private __stylesController;
    value: string;
    options: SelectOption[];
    id: string;
    name: string;
    error?: string;
    disabled: boolean;
    required: boolean;
    corners: RoundedCorners;
    __selectEl: HTMLSelectElement;
    __labelEl: HTMLLabelElement;
    __errorEl: MonoTextComp;
    private __onBlur;
    private __onInput;
    private __onChange;
    private __hasError;
    private __renderError;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-select': MonoSelectComp;
    }
}

declare type ButtonGroupOption = {
    selected?: boolean;
    value: string;
    text: string;
};
declare class MonoButtonGroupComp extends LitElement {
    static styles: lit.CSSResultGroup;
    private __spreadController;
    private __stylesController;
    value: string;
    options: ButtonGroupOption[];
    id: string;
    name: string;
    error?: string;
    disabled: boolean;
    required: boolean;
    tone: InputTone;
    corners: RoundedCorners;
    focusedValue: string;
    __legendEl: HTMLLabelElement;
    __inputsEl: Array<HTMLInputElement>;
    __labelsEl: Array<HTMLLabelElement>;
    __errorEl: MonoTextComp;
    private __onInput;
    private __onChange;
    private __onFocus;
    private __onBlur;
    private __hasError;
    private __renderError;
    private __computeButtonStyle;
    private __computeFocusStyle;
    private __computeCornersForIndex;
    private __focus;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-button-group': MonoButtonGroupComp;
    }
}

declare type InputMaskType = 'number' | 'date' | 'phone';
declare type InputMode = 'none' | 'text' | 'decimal' | 'numeric' | 'tel' | 'search' | 'email' | 'url';
declare class MonoTextFieldComp extends LitElement {
    static styles: lit.CSSResultGroup;
    private __spreadController;
    private __stylesController;
    value: string;
    placeholder: string;
    id: string;
    name: string;
    error?: string;
    disabled: boolean;
    required: boolean;
    maskType?: InputMaskType;
    inputMode: InputMode;
    corners: RoundedCorners;
    __inputEl: HTMLInputElement;
    __labelEl: HTMLLabelElement;
    __errorEl: MonoTextComp;
    __computMaskType(): "99999999999999999999999999999999999999999999999999999999999" | "9999999999" | "99/99/9999" | null;
    private __onInput;
    private __onChange;
    private __hasError;
    private __renderError;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-textfield': MonoTextFieldComp;
    }
}

declare type SpinnerSize = 'base' | 'md' | 'lg' | 'xl' | '2xl';
declare class MonoSpinnerComp extends LitElement {
    private __spreadController;
    private __stylesController;
    private __animationController;
    size: SpinnerSize;
    tone?: Tone;
    private __computSize;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-spinner': MonoSpinnerComp;
    }
}

declare type AlertType = 'error' | 'error-with-icon' | 'success' | 'success-with-icon';
declare class MonoAlertComp extends LitElement implements Hideable {
    static styles: lit.CSSResultGroup;
    private __spreadController;
    private __stylesController;
    type: AlertType;
    hidden: boolean;
    __computePrimaryColor(): "alert" | "success";
    __computeInsetPrimaryColor(): (context: twind.Context) => twind.ThemeColor | undefined;
    __getIcon(): typeof nothing | lit.TemplateResult<1>;
    private __getSlotNamed;
    isHidden(): boolean;
    updated(changed: PropertyValues<this>): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-alert': MonoAlertComp;
    }
}

declare type DividerStyle = 'none' | 'gradient';
declare class MonoCardLayoutComp extends LitElement {
    private __spreadController;
    private __stylesController;
    backgroundImage: string;
    dividerStyle: DividerStyle;
    private renderDivider;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-card-layout': MonoCardLayoutComp;
    }
}

declare type KeyValuePair = {
    key: string;
    value: string;
};
declare class MonoDescriptionListComp extends LitElement {
    private __spreadController;
    private __stylesController;
    values: KeyValuePair[];
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-description-list': MonoDescriptionListComp;
    }
}

declare const setupReset: (includeBaseFont?: boolean) => void;

declare class MonoBoxComp extends LitElement {
    private __spreadController;
    private __stylesController;
    private __uniqueSlotController;
    as: ElementTagName;
    clsx: string;
    grow: boolean;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-box': MonoBoxComp;
    }
}

declare class MonoTextLinkComp extends LitElement {
    private __spreadController;
    private __stylesController;
    href: string;
    tone: Tone;
    size?: FontSize;
    family?: FontFamily;
    weight?: FontWeigth;
    tracking?: LetterSpacing;
    alignText?: TextAlign;
    inline: boolean;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-text-link': MonoTextLinkComp;
    }
}

declare class MonoStrongComp extends LitElement {
    private __spreadController;
    private __stylesController;
    inline: boolean;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-strong': MonoStrongComp;
    }
}

declare class MonoColumnsComp extends LitElement {
    private __spreadController;
    private __stylesController;
    private __uniqueSlotController;
    space: Space;
    alignX?: AlignX;
    alignY?: AlignY;
    collapseBelow?: ResponsiveBreakpoint;
    columnsHaveContainer?: boolean;
    private __collapsableSpaceX;
    private __computeSpaceX;
    private __computeAlignX;
    private __computeAlignY;
    private __collapsableWidth;
    private __computeColumnWidth;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-columns': MonoColumnsComp;
    }
}

declare class MonoRangeSliderComp extends LitElement {
    static styles: lit.CSSResultGroup;
    private _spreadController;
    private __stylesController;
    value: string;
    min: string;
    max: string;
    step: string;
    id: string;
    name: string;
    error?: string;
    disabled: boolean;
    required: boolean;
    currency: boolean;
    corners: RoundedCorners;
    __inputEl: HTMLInputElement;
    __labelEl: HTMLLabelElement;
    __errorEl: MonoTextComp;
    private __currencyFormatter;
    private __onInput;
    private __onChange;
    private __hasError;
    private __renderError;
    private __computeCurrentValue;
    private __computeToneColor;
    private __computeTooltipColor;
    private __computeHighlightThumbColor;
    private __formatValue;
    private __renderTooltip;
    firstUpdated(changedProperties: PropertyValues<this>): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-rangeslider': MonoRangeSliderComp;
    }
}

declare class MonoHelpTooltipComp extends LitElement {
    static styles: lit.CSSResultGroup[];
    private __spreadController;
    private __stylesController;
    show: boolean;
    __target: HTMLButtonElement;
    __tooltip: HTMLElement;
    __tippy?: Instance;
    firstUpdated(changedProperties: PropertyValues<this>): void;
    disconnectedCallback(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-help-tooltip': MonoHelpTooltipComp;
    }
}

declare class MonoTooltipComp extends LitElement {
    static styles: lit.CSSResultGroup[];
    private __spreadController;
    private __stylesController;
    show: boolean;
    __target: HTMLButtonElement;
    __tooltip: HTMLElement;
    __tippy?: Instance;
    firstUpdated(changedProperties: PropertyValues<this>): void;
    disconnectedCallback(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-tooltip': MonoTooltipComp;
    }
}

declare class MonoHiddenVisuallyComp extends LitElement implements Hideable {
    private __spreadController;
    private __stylesController;
    isHidden(): boolean;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-hidden-visually': MonoHiddenVisuallyComp;
    }
}

declare class MonoHiddenComp extends LitElement implements Hideable {
    static styles: lit.CSSResultGroup;
    private __spreadController;
    private __stylesController;
    as: ElementTagName;
    inline: boolean;
    above?: ResponsiveBreakpoint;
    below?: ResponsiveBreakpoint;
    __rootEl: HTMLElement;
    isHidden(): boolean;
    render(): lit.TemplateResult<1 | 2>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-hidden': MonoHiddenComp;
    }
}

declare class MonoResizeObserverComp extends LitElement {
    static styles: lit.CSSResultGroup;
    private __resizeObserver?;
    private __observedElements;
    connectedCallback(): void;
    disconnectedCallback(): void;
    __handleSlotChange(): void;
    render(): lit.TemplateResult<1>;
}
declare global {
    interface HTMLElementTagNameMap {
        'mono-resize-observer': MonoResizeObserverComp;
    }
}

export { AlertType, AlignX, AlignY, ButtonElementTagName, ButtonGroupOption, ButtonSize, ButtonVariant, CardElementTagName, ColumnWidth, DividerStyle, ElementTagName, FontFamily, FontSize, FontWeigth, HeadingLevel, Hideable, IconName, InputMaskType, InputTone, KeyValuePair, LetterSpacing, MonoAlertComp, MonoBoxComp, MonoButtonComp, MonoButtonGroupComp, MonoCardComp, MonoCardLayoutComp, MonoColumnComp, MonoColumnsComp, MonoDescriptionListComp, MonoHeadingComp, MonoHelpTooltipComp, MonoHiddenComp, MonoHiddenVisuallyComp, MonoIconComp, MonoRangeSliderComp, MonoResizeObserverComp, MonoSelectComp, MonoSpinnerComp, MonoStackComp, MonoStrongComp, MonoTextComp, MonoTextFieldComp, MonoTextLinkComp, MonoTooltipComp, ResponsiveBreakpoint, RoundedCorners, SelectOption, Space, SpinnerSize, StackElementTagName, TextAlign, Tone, setupReset };