import { FC, WebCellProps, WebCell, WebField } from "web-cell";
import { JsxChildren, VNode, JsxProps } from "dom-renderer";
import { Defer } from "iterable-observer";
import { TimeData } from "web-utility";
type Subtle<T extends string> = `${T}${'' | '-subtle'}`;
export enum Status {
    primary = "primary",
    secondary = "secondary",
    tertiary = "tertiary",
    success = "success",
    info = "info",
    warning = "warning",
    danger = "danger"
}
export enum Theme {
    light = "light",
    dark = "dark"
}
export type BasicColor = 'body' | 'black' | 'white';
export type TextColor = BasicColor | Exclude<keyof typeof Status, 'tertiary'> | keyof typeof Theme;
export type BackgroundColor = Subtle<TextColor> | `body-${'emphasis' | 'secondary' | 'tertiary'}` | BasicColor | 'transparent';
export type Size = 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
export type PositionY = 'top' | 'bottom';
export interface RatioProps extends WebCellProps<HTMLDivElement> {
    aspectRatio?: number | '1x1' | '4x3' | '16x9' | '21x9';
}
export const Ratio: FC<RatioProps>;
export interface ContainerProps extends WebCellProps {
    fluid?: boolean | Size;
}
export const Container: FC<ContainerProps>;
export type RowProps = Partial<Record<'xs' | Size, number | 'auto'>> & WebCellProps;
export const Row: FC<RowProps>;
export type ColProps = RowProps;
export const Col: FC<ColProps>;
export type EdgePosition = 'top' | 'bottom' | 'left' | 'right';
export type TouchHandler = (edge: EdgePosition) => any;
export interface ScrollBoundaryProps extends WebCellProps, Partial<Record<EdgePosition, JsxChildren>> {
    onTouch: TouchHandler;
}
export const ScrollBoundary: FC<ScrollBoundaryProps>;
export interface CollapseProps extends WebCellProps<HTMLElement> {
    dimension?: 'width' | 'height';
    in?: boolean;
}
export const Collapse: FC<CollapseProps>;
export type FormGroupProps = WebCellProps<HTMLDivElement>;
export const FormGroup: FC<FormGroupProps>;
export type FormLabelProps = WebCellProps<HTMLLabelElement>;
export const FormLabel: FC<FormLabelProps>;
export interface FloatingLabelProps extends FormLabelProps {
    label: string;
}
export const FloatingLabel: FC<FloatingLabelProps>;
export interface InputGroupProps extends WebCellProps<HTMLDivElement> {
    size?: 'sm' | 'lg';
}
export const InputGroup: FC<InputGroupProps>;
export const InputGroupText: FC<WebCellProps<HTMLSpanElement>>;
export type FormControlTag = 'input' | 'textarea' | 'select';
export type FormControlProps<T extends FormControlTag> = WebCellProps & Omit<JSX.IntrinsicElements[T], 'size'> & {
    as?: T;
    htmlSize?: number;
    size?: 'sm' | 'lg';
    plaintext?: boolean;
};
export const FormControl: <T extends FormControlTag = "input">({ as: Tag, className, htmlSize, size, plaintext, ...props }: FormControlProps<T>) => VNode;
export interface FormCheckProps extends WebCellProps<HTMLInputElement> {
    type: 'radio' | 'checkbox' | 'switch';
    inline?: boolean;
    reverse?: boolean;
    label?: JsxChildren;
}
export const FormCheck: FC<FormCheckProps>;
export type FormFieldProps<T extends FormControlTag> = FormGroupProps & FormLabelProps & FormControlProps<T> & {
    label?: string;
    labelFloat?: boolean;
};
export const FormField: <T extends FormControlTag = "input">({ className, label, labelFloat, ...props }: FormFieldProps<T>) => VNode;
export interface BadgeProps extends WebCellProps<HTMLAnchorElement> {
    bg?: TextColor;
    text?: TextColor;
    pill?: boolean;
}
export const Badge: FC<BadgeProps>;
export interface IconProps extends WebCellProps {
    name: string;
    color?: TextColor;
    size?: number;
}
export const Icon: FC<IconProps>;
export interface BGIconProps extends IconProps {
    type?: 'square' | 'circle';
}
export const BGIcon: FC<BGIconProps>;
export interface FAIconProps extends Omit<IconProps, 'size'> {
    group?: 'solid' | 'brands' | 'regular' | 'light' | 'duotone';
    size?: 'xs' | 'sm' | 'lg' | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10;
    fixedWidth?: boolean;
    color?: TextColor;
    inverse?: boolean;
    border?: boolean;
    rotate?: 90 | 180 | 270;
    flip?: 'horizontal' | 'vertical' | 'both';
    animation?: 'spin' | 'pulse';
    pull?: 'left' | 'right';
    stack?: 1 | 2;
    listItem?: boolean;
}
export const FAIcon: FC<FAIconProps>;
export interface FABGIconProps extends FAIconProps {
    type: 'square' | 'circle';
}
export const FABGIcon: FC<FABGIconProps>;
export interface ProgressBarProps extends WebCellProps<HTMLDivElement>, Partial<Record<'min' | 'max' | 'now', number>> {
    striped?: boolean;
    animated?: boolean;
    variant?: keyof typeof Status;
    label?: boolean | ((now: number) => JsxChildren);
}
export const ProgressBar: FC<ProgressBarProps>;
export interface ButtonProps extends WebCellProps<HTMLButtonElement>, Omit<WebCellProps<HTMLAnchorElement>, 'type'>, Pick<FormControlProps<'input'>, 'size'> {
    variant?: TextColor | `outline-${TextColor}` | 'link';
    active?: boolean;
}
export const Button: FC<ButtonProps>;
export function isButton(node: JsxChildren): node is VNode;
export type IconButtonProps = IconProps & Omit<ButtonProps, 'size'>;
export const IconButton: FC<IconButtonProps>;
export const CloseButton: FC<WebCellProps<HTMLButtonElement>>;
export interface ToggleButtonProps extends WebCellProps<HTMLInputElement>, Pick<ButtonProps, 'variant'> {
    type: Exclude<FormCheckProps['type'], 'switch'>;
}
export const ToggleButton: FC<ToggleButtonProps>;
export const OffcanvasTitle: FC<WebCellProps<HTMLHeadingElement>>;
export interface OffcanvasHeaderProps extends WebCellProps<HTMLDivElement> {
    closeButton?: boolean;
    onHide?: () => any;
}
export const OffcanvasHeader: FC<OffcanvasHeaderProps>;
export const OffcanvasBody: FC<WebCellProps<HTMLDivElement>>;
export interface OffcanvasProps extends Omit<OffcanvasHeaderProps, 'closeButton'> {
    backdrop?: boolean | 'static';
    show?: boolean;
}
export const Offcanvas: FC<OffcanvasProps>;
export interface OffcanvasBoxProps extends OffcanvasProps, OffcanvasHeaderProps {
    titleId?: string;
}
export const OffcanvasBox: FC<OffcanvasBoxProps>;
export class SplitView extends HTMLElement {
    connectedCallback(): void;
    toggleDrag({ type, target, pointerId }: PointerEvent): void;
    watchLine(element: HTMLElement): Promise<void>;
    render(): VNode;
}
export interface ListGroupProps extends WebCellProps<HTMLDivElement> {
    variant?: 'flush';
    numbered?: boolean;
    horizontal?: true | Size;
}
export const ListGroup: FC<ListGroupProps>;
export interface ListGroupItemProps extends WebCellProps<HTMLAnchorElement>, Partial<Record<'active' | 'disabled', boolean>> {
    variant?: keyof typeof Status | keyof typeof Theme;
}
export const ListGroupItem: FC<ListGroupItemProps>;
export interface TableProps extends WebCellProps<HTMLTableElement> {
    variant?: TextColor;
    size?: 'sm';
    responsive?: boolean | Size;
    striped?: boolean | 'columns';
    hover?: boolean;
    bordered?: boolean;
    borderless?: boolean;
    caption?: 'top';
}
export const Table: FC<TableProps>;
export interface JumbotronProps extends Omit<ContainerProps, 'title'>, Record<'title' | 'description', JsxChildren> {
    bg?: BackgroundColor;
    rounded?: 0 | 1 | 2 | 3 | 4 | 5;
}
export const Jumbotron: FC<JumbotronProps>;
export type ImageProps = WebCellProps<HTMLImageElement> & Partial<Record<'fluid' | 'rounded' | 'roundedCircle' | 'thumbnail', boolean>>;
export const Image: FC<ImageProps>;
export interface CardProps extends WebCellProps<HTMLDivElement> {
    bg?: TextColor;
    text?: TextColor | 'white' | 'muted';
    border?: TextColor;
    body?: boolean;
}
export const Card: FC<CardProps>;
export const CardHeader: FC<WebCellProps<HTMLDivElement>>;
export const CardBody: FC<WebCellProps<HTMLDivElement>>;
export const CardFooter: FC<WebCellProps<HTMLDivElement>>;
export const CardTitle: FC<WebCellProps<HTMLHeadingElement>>;
export interface CardImgProps extends ImageProps {
    variant?: PositionY;
}
export const CardImg: FC<CardImgProps>;
export interface MediaObjectProps extends WebCellProps {
    listItem?: boolean;
    title: string;
    image: JsxChildren;
    imageRow?: 'start' | 'center' | 'end';
    imageColumn?: 'start' | 'end';
}
export const MediaObject: FC<MediaObjectProps>;
export const AccordionItem: FC<WebCellProps<HTMLDivElement>>;
export const AccordionHeader: FC<WebCellProps<HTMLHeadingElement>>;
export const AccordionBody: FC<CollapseProps>;
export interface AccordionProps {
    flush?: boolean;
    alwaysOpen?: boolean;
}
export interface Accordion extends WebCell<AccordionProps> {
}
export class Accordion extends HTMLElement implements WebCell<AccordionProps> {
    accessor flush: boolean;
    accessor alwaysOpen: boolean;
    connectedCallback(): void;
    handleFlush(flush: boolean): void;
    handleClick(_: any, { nextElementSibling: currentCollapse }: HTMLHeadingElement): void;
    render(): VNode;
}
export const Dropdown: FC<WebCellProps<HTMLDivElement>>;
export const DropdownToggle: FC<ButtonProps>;
export const DropdownMenu: FC<WebCellProps>;
export const DropdownItem: FC<WebCellProps<HTMLAnchorElement>>;
export interface DropdownButtonProps extends WebCellProps, ButtonProps {
    boxClass?: string;
    buttonClass?: string;
    caption: JsxChildren;
}
export class DropdownButton extends HTMLElement {
    props: DropdownButtonProps;
    accessor boxClass: string;
    accessor buttonClass: string;
    accessor variant: ButtonProps['variant'];
    accessor size: ButtonProps['size'];
    accessor caption: JsxChildren;
    accessor disabled: boolean;
    accessor show: boolean;
    renderContent(): VNode;
    render(): VNode;
}
export type NavbarBrandProps = JsxProps<HTMLAnchorElement>;
export const NavbarBrand: FC<NavbarBrandProps>;
export type NavbarToggleProps = JsxProps<HTMLButtonElement>;
export const NavbarToggle: FC<NavbarToggleProps>;
export interface NavbarProps extends WebCellProps {
    variant?: 'light' | 'dark';
    bg?: BackgroundColor;
    expand?: boolean | Size;
    fixed?: PositionY;
    sticky?: PositionY;
}
export const Navbar: FC<NavbarProps>;
export interface OffcanvasNavbarProps extends OffcanvasBoxProps, NavbarProps, ContainerProps {
    brand?: JsxChildren;
}
export interface OffcanvasNavbar extends WebCell {
}
export class OffcanvasNavbar extends HTMLElement implements WebCell {
    props: OffcanvasNavbarProps;
    accessor variant: OffcanvasNavbarProps['variant'];
    accessor bg: OffcanvasNavbarProps['bg'];
    accessor expand: OffcanvasNavbarProps['expand'];
    accessor fixed: OffcanvasNavbarProps['fixed'];
    accessor sticky: OffcanvasNavbarProps['sticky'];
    accessor fluid: ContainerProps['fluid'];
    accessor title: string;
    titleId: string;
    accessor brand: OffcanvasNavbarProps['brand'];
    offcanvasId: string;
    accessor open: boolean;
    accessor closeButton: boolean;
    connectedCallback(): void;
    disconnectedCallback(): void;
    close: (event?: KeyboardEvent | MouseEvent) => void;
    handleLink: (this: Node, event: Event) => any;
    renderContent(): VNode;
    render(): VNode;
}
export interface NavLinkProps extends WebCellProps<HTMLAnchorElement> {
    active?: boolean;
}
export const NavLink: FC<NavLinkProps>;
export interface NavDropdownProps extends Omit<NavLinkProps, 'title' | 'type'>, Pick<ButtonProps, 'disabled' | 'onClick'> {
    title: JsxChildren;
}
export const NavDropdown: FC<NavDropdownProps>;
export interface NavProps extends WebCellProps {
    variant?: 'pills' | 'underline' | 'tabs';
    fill?: boolean;
    justify?: boolean;
}
export interface Nav extends WebCell<NavProps> {
}
export class Nav extends HTMLElement implements WebCell<NavProps> {
    accessor variant: 'pills' | 'underline' | 'tabs' | undefined;
    accessor fill: boolean;
    accessor justify: boolean;
    protected updateClass({ variant, fill, justify }?: this): void;
    connectedCallback(): void;
    render(): VNode;
}
export interface TabProps {
    caption: JsxChildren;
}
export interface Tab extends WebCell<TabProps> {
}
export class Tab extends HTMLElement implements WebCell<TabProps> {
    caption: JsxChildren;
    connectedCallback(): void;
}
export interface Tabs extends WebCell {
}
export class Tabs extends HTMLElement implements WebCell {
    accessor tabMeta: TabProps[];
    accessor currentIndex: number;
    mountedCallback(): void;
    handleTabClick(event: MouseEvent, { dataset: { index } }: HTMLAnchorElement): void;
    turnPaneTo(index: number): void;
    renderContent(): VNode;
    render(): VNode;
}
export interface ButtonGroupProps extends WebCellProps<HTMLDivElement> {
    vertical?: boolean;
    size?: 'sm' | 'lg';
}
export const ButtonGroup: FC<ButtonGroupProps>;
export type ButtonToolbarProps = WebCellProps<HTMLDivElement>;
export const ButtonToolbar: FC<ButtonToolbarProps>;
export interface RangeInputProps extends WebCellProps<HTMLInputElement> {
    icon?: JsxChildren | ((itemValue: number) => JsxChildren);
}
export interface RangeInput extends WebField<RangeInputProps> {
}
export class RangeInput extends HTMLElement implements WebField<RangeInputProps> {
    accessor type: string;
    accessor min: number | undefined;
    accessor max: number | undefined;
    accessor step: number;
    accessor icon: RangeInputProps['icon'] | undefined;
    connectedCallback(): void;
    handleChange: ({ currentTarget }: Event) => void;
    renderItem(index: number): VNode;
    render(): VNode;
}
export interface SpinnerProps extends WebCellProps<HTMLDivElement> {
    variant?: TextColor;
    size?: 'sm';
    animation?: 'border' | 'grow';
}
export const Spinner: FC<SpinnerProps>;
export interface SpinnerBoxProps extends SpinnerProps {
    cover?: boolean;
}
export const SpinnerBox: FC<SpinnerBoxProps>;
export interface AlertProps extends WebCellProps {
    variant?: TextColor;
    title?: string;
    dismissible?: boolean;
    show?: boolean;
    onClose?: (event: MouseEvent) => any;
}
export const Alert: FC<AlertProps>;
export type AlertLinkProps = WebCellProps<HTMLAnchorElement>;
export const AlertLink: FC<AlertLinkProps>;
export const Tooltip: FC<WebCellProps>;
export interface TooltipBoxProps extends WebCellProps {
    content: JsxChildren;
}
export interface TooltipBox extends WebCell {
}
export class TooltipBox extends HTMLElement implements WebCell {
    props: TooltipBoxProps;
    content: JsxChildren;
    accessor show: boolean;
    connectedCallback(): void;
    disconnectedCallback(): void;
    handleToggle: () => boolean;
    render(): VNode;
}
export class DialogClose extends Error {
    constructor(message?: string);
}
export interface DialogProps<T = any> {
    defer?: Defer<T>;
}
export class Dialog<T = any> {
    accessor defer: Defer<T> | undefined;
    Component: FC;
    constructor(Factory: FC<DialogProps<T>>);
    open(): Promise<T>;
}
export interface ModalProps extends WebCellProps<HTMLDivElement> {
    backdrop?: 'static' | boolean;
    size?: 'sm' | 'lg' | 'xl';
    fullscreen?: true | `${Size}-down`;
    centered?: boolean;
    scrollable?: boolean;
    animation?: boolean;
    show?: boolean;
}
export const Modal: FC<ModalProps>;
export interface ModalHeaderProps extends WebCellProps<HTMLDivElement> {
    closeButton?: boolean;
}
export const ModalHeader: FC<ModalHeaderProps>;
export type ModalTitleProps = WebCellProps<HTMLHeadingElement>;
export const ModalTitle: FC<ModalTitleProps>;
export type ModalBodyProps = WebCellProps<HTMLDivElement>;
export const ModalBody: FC<ModalBodyProps>;
export type ModalFooterProps = WebCellProps<HTMLDivElement>;
export const ModalFooter: FC<ModalFooterProps>;
export interface ImagePreview extends WebCell<ImageProps> {
}
export class ImagePreview extends HTMLElement implements WebCell<ImageProps> {
    accessor src: string;
    accessor loading: ImageProps['loading'];
    accessor fluid: boolean;
    accessor rounded: boolean;
    accessor roundedCircle: boolean;
    accessor thumbnail: boolean;
    accessor downloading: boolean;
    accessor loadedPath: string;
    accessor viewing: boolean;
    connectedCallback(): void;
    load(path: string): Promise<void>;
    render(): VNode;
}
export type FilePreviewProps = ImageProps & WebCellProps<HTMLAudioElement> & WebCellProps<HTMLVideoElement> & WebCellProps<HTMLAnchorElement> & {
    type?: HTMLInputElement['accept'];
    path: string;
};
export const FileTypeMap: {
    stream: string;
    compressed: string;
    msword: string;
    document: string;
    powerpoint: string;
    presentation: string;
    excel: string;
    sheet: string;
};
export const FilePreview: FC<FilePreviewProps>;
export interface FilePickerProps extends WebCellProps<HTMLInputElement> {
    onChange?: (event: CustomEvent<{
        value: string;
        file?: File;
    }>) => any;
}
export interface FilePicker extends WebField<FilePickerProps> {
}
export class FilePicker extends HTMLElement implements WebField<FilePickerProps> {
    accessor accept: HTMLInputElement['accept'];
    accessor multiple: boolean;
    accessor file: File | undefined;
    get fileType(): string;
    connectedCallback(): void;
    handleAdd: ({ currentTarget }: Event) => void;
    handleClear: (event: MouseEvent) => void;
    renderInput(): VNode;
    renderContent(): VNode;
    render(): VNode;
}
export abstract class FileModel {
    accessor files: string[];
    clear(): void;
    /**
     * Override this method for Network calling,
     * then call `super.upload(fileURL)` to update `this.files` array.
     */
    upload(file: string | Blob): Promise<string>;
    /**
     * Override this method for Network calling,
     * then call `super.delete(fileURL)` to update `this.files` array.
     */
    delete(file: string): Promise<void>;
    move(sourceIndex: number, targetIndex: number): void;
}
export interface WebFileFieldProps extends Omit<WebCellProps<HTMLInputElement>, 'defaultValue' | 'value'> {
    defaultValue?: string | string[];
    value?: string | string[];
}
export interface FileUploaderProps extends WebFileFieldProps {
    store: FileModel;
}
export interface WebFileField extends Pick<FileUploaderProps, 'defaultValue' | 'value'>, Omit<WebField<FileUploaderProps>, 'defaultValue' | 'value' | 'props'> {
    props: FileUploaderProps;
}
export interface FileUploader extends WebFileField {
}
export class FileUploader extends HTMLElement implements WebFileField {
    accessor accept: HTMLInputElement['accept'];
    accessor multiple: boolean;
    accessor store: FileModel;
    accessor pickIndex: number | undefined;
    mountedCallback(): void;
    updateFiles(value: this['value']): void;
    emitFiles(files?: FileModel['files']): void;
    handleAdd: () => Promise<void>;
    handleDrop: (index: number) => (event: DragEvent) => void;
    handleChange: (oldURI?: string) => FilePickerProps["onChange"];
    renderContent(): VNode;
    render(): VNode;
}
export interface CodeBlockProps extends WebCellProps<HTMLPreElement> {
    name?: string;
    value: string;
    language: string;
    theme?: string;
}
export interface CodeBlock extends WebCell<CodeBlockProps> {
}
export class CodeBlock extends HTMLElement implements WebCell<CodeBlockProps> {
    accessor name: string;
    accessor value: string;
    accessor language: string;
    accessor theme: string;
    get markup(): string;
    get dataURI(): string;
    connectedCallback(): void;
    render(): VNode;
}
export interface CarouselItemProps extends WebCellProps<HTMLDivElement> {
    interval?: number;
}
export const CarouselItem: FC<CarouselItemProps>;
export const CarouselCaption: FC<WebCellProps<HTMLDivElement>>;
interface ItemMeta {
    caption?: string;
}
export interface CarouselProps {
    interval?: number;
}
export interface Carousel extends WebCell<CarouselProps> {
}
export class Carousel extends HTMLElement implements WebCell<CarouselProps> {
    accessor interval: number | undefined;
    accessor itemMeta: ItemMeta[];
    accessor currentIndex: number;
    connectedCallback(): void;
    disconnectedCallback(): void;
    mountedCallback(): void;
    turnByOffset(delta: number): void;
    handleButtonClick(_: MouseEvent, { dataset }: HTMLButtonElement): void;
    handleButtonPress({ key }: KeyboardEvent, { dataset }: HTMLButtonElement): void;
    handleIndicatorsButtonClick(_: MouseEvent, { dataset }: HTMLButtonElement): void;
    handleIndicatorsButtonPress({ key }: KeyboardEvent, { dataset }: HTMLButtonElement): void;
    handleActiveItem(currentIndex: number): void;
    renderContent(): VNode;
    render(): VNode;
}
export type BreadcrumbProps = WebCellProps;
export const BreadCrumb: FC<BreadcrumbProps>;
export interface BreadcrumbItemProps extends WebCellProps<HTMLAnchorElement> {
    active?: boolean;
}
export const BreadcrumbItem: FC<BreadcrumbItemProps>;
export interface PaginationProps extends WebCellProps<HTMLDivElement> {
    size?: 'sm' | 'lg';
}
export const Pagination: FC<PaginationProps>;
export interface PaginationItemProps extends WebCellProps<HTMLLIElement> {
    href?: string;
    active?: boolean;
    disabled?: boolean;
}
export const PaginationItem: FC<PaginationItemProps>;
export type PageMeta = Record<'pageSize' | 'pageIndex', number>;
export interface PagerProps extends PageMeta {
    pageCount: number;
    onChange?: (meta: PageMeta) => any;
}
export const Pager: FC<PagerProps>;
export interface StepProps extends WebCellProps {
    icon?: JsxChildren;
    active?: boolean;
    disabled?: boolean;
}
export function Step({ active, disabled, icon, children: defaultSlot, ...rest }: StepProps): VNode;
export function isStep(node: JsxChildren): node is VNode;
export interface StepperProps extends WebCellProps {
}
export function Stepper({ className, children, ...rest }: StepperProps): VNode;
interface TimeUnit {
    scale: number;
    label: string;
}
interface TimeSection {
    value: number;
    label: string;
}
export interface CountDownProps {
    endTime?: string | Date | number;
}
export interface CountDown extends WebCell<CountDownProps> {
}
export class CountDown extends HTMLElement implements WebCell<CountDownProps> {
    accessor endTime: CountDownProps['endTime'];
    accessor rest: number;
    accessor units: TimeUnit[];
    get timeSections(): TimeSection[];
    tick: () => void;
    mountedCallback(): void;
    disconnectedCallback(): void;
    render(): VNode;
}
export interface DateData {
    date: TimeData;
    content: JsxChildren;
    link?: string;
}
export interface MonthCalendarProps extends Omit<TableProps, 'variant' | 'onChange' | 'onSelect'>, Pick<ButtonProps, 'variant'> {
    locale?: Navigator['language'];
    value?: DateData[];
    onSelect?: (event: CustomEvent<DateData>) => any;
    onChange?: (event: CustomEvent<Date>) => any;
}
export interface MonthCalendar extends WebCell<MonthCalendarProps> {
}
export class MonthCalendar extends HTMLElement implements WebCell<MonthCalendarProps> {
    accessor variant: MonthCalendarProps['variant'];
    accessor locale: Navigator['language'];
    accessor value: DateData[];
    get weekFormatter(): Intl.DateTimeFormat;
    accessor currentDate: Date;
    get dateGrid(): Date[][];
    changeMonth(delta: number): void;
    renderDate: (date: Date) => VNode;
    render(): VNode;
}

//# sourceMappingURL=index.d.ts.map