@mono-lit/helper 0.0.0-stage → 0.0.1

package/dist/src/components/checkbox/checkbox-utils.d.ts

@@ -0,0 +1,35 @@
+import { CheckboxSize, CheckboxColor } from './checkbox-types.js';
+/**
+ * Validate checkbox props
+ */
+export declare function validateCheckboxProps(props: {
+    size?: CheckboxSize;
+    color?: CheckboxColor;
+}): boolean;
+/**
+ * Generate ARIA attributes for accessibility
+ */
+export declare function generateCheckboxAttributes(disabled: boolean, checked: boolean, indeterminate: boolean, label: string | undefined): Record<string, string | boolean | undefined>;
+/**
+ * Generate root CSS classes for checkbox
+ */
+export declare function generateCheckboxRootClasses(props: {
+    size?: CheckboxSize;
+    color?: CheckboxColor;
+    checked?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+}): string;
+/**
+ * Generate CSS classes for checkbox box element
+ */
+export declare function generateCheckboxBoxClasses(props: {
+    size?: CheckboxSize;
+}): string;
+/**
+ * Generate CSS classes for checkbox icon element
+ */
+export declare function generateCheckboxIconClasses(props: {
+    size?: CheckboxSize;
+    type?: 'check' | 'indeterminate';
+}): string;

package/dist/src/components/checkbox/index.d.ts

@@ -0,0 +1,4 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoCheckbox } from './mono-checkbox.js';
+export type { CheckboxSize, CheckboxColor, CheckboxProps, CheckboxEvents } from './checkbox-types.js';
+export { validateCheckboxProps, generateCheckboxAttributes } from './checkbox-utils.js';

package/dist/src/components/checkbox/index.shadow.d.ts

@@ -0,0 +1,5 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoCheckboxShadow } from './mono-checkbox.shadow.js';
+export { MonoCheckboxCore } from './checkbox-core.js';
+export type { CheckboxSize, CheckboxColor, CheckboxProps, CheckboxEvents, } from './checkbox-types.js';
+export { validateCheckboxProps, generateCheckboxAttributes, } from './checkbox-utils.js';

package/dist/src/components/checkbox/mono-checkbox.d.ts

@@ -0,0 +1,34 @@
+import { LitElement } from 'lit';
+declare const MonoCheckbox_base: import('../../composables/hybird-prop').Constructor<import('./checkbox-core.js').MonoCheckboxCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-checkbox` (default build, `@mono-lit/helper/ui/checkbox`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`) with the light-DOM slot strategy: `slot="icon|
+ * indeterminate-icon|label|description"` children are captured in
+ * `connectedCallback`, the template renders empty `[data-mono-slot]` targets
+ * (via the core's default `_renderCustomIcon`/`_renderLabelBlock`), and the
+ * captured nodes are re-placed in `updated()`. All render-mode-agnostic logic
+ * lives in `MonoCheckboxCore`. The shadow build (`@mono-lit/helper/ui/shadow/checkbox`)
+ * shares the mixin but uses native `<slot>`. Both register `mono-checkbox`, so a
+ * document loads only one.
+ */
+export declare class MonoCheckbox extends MonoCheckbox_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _slotsCaptured;
+    private _slotIcon;
+    private _slotIndeterminateIcon;
+    private _slotLabel;
+    private _slotDescription;
+    connectedCallback(): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _captureSlots;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-checkbox': MonoCheckbox;
+    }
+}
+export {};

package/dist/src/components/checkbox/mono-checkbox.shadow.d.ts

@@ -0,0 +1,45 @@
+import { LitElement, nothing, TemplateResult } from 'lit';
+declare const MonoCheckboxShadow_base: import('../../composables/hybird-prop').Constructor<import('./checkbox-core.js').MonoCheckboxCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-checkbox` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/checkbox`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM and styles are scoped (`:host{display:inline-block}` —
+ * the `.mono-checkbox` class lives on the inner `<label>`). The checked/
+ * indeterminate visual state is the wrapper class (CSS `::before`/`::after`), so
+ * it server-renders from `this.checked`/`this.indeterminate`. Slots use native
+ * `<slot>`: the `label`/`description` slots carry the prop text as native fallback
+ * (shown server-side); custom icon slots are bare `<slot name="icon">` gated on
+ * `checked`/`indeterminate`; slot presence is detected in `firstUpdated()` via
+ * `assignedNodes()` (DSD assigns at parse time → no `slotchange` after upgrade).
+ * Interactivity needs the first client update to flush (so `@change` binds) —
+ * hence the defer-hydration poll. Shares all logic with the light build via
+ * `MonoCheckboxCore`; both register `mono-checkbox`, so a document loads one.
+ */
+export declare class MonoCheckboxShadow extends MonoCheckboxShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    protected updated(changed: Map<string, unknown>): void;
+    private _slotFor;
+    private _slotHasContent;
+    private _onSlotChange;
+    /**
+     * The sublabel region answers to `slot="sublabel"` and to the older
+     * `slot="description"` (nested inside it), so its presence is the union.
+     */
+    private _sublabelHasContent;
+    private _setSlotState;
+    /** Reconcile the 4 slot-presence flags from their slots' assigned content. */
+    private _scanSlots;
+    /**
+     * Inline SVG, not the `i-mdi-loading` utility class: a shadow root cannot see the
+     * page's utility CSS, so the light build's icon class would render nothing here.
+     * `fill="currentColor"` keeps it on the box's icon colour; the spin comes from the
+     * adopted `checkbox.css`.
+     */
+    protected _renderLoadingIcon(): TemplateResult;
+    protected _renderCustomIcon(): TemplateResult | typeof nothing;
+    protected _renderLabelBlock(): TemplateResult | typeof nothing;
+}
+export {};

package/dist/src/components/chip/chip-core.d.ts

@@ -0,0 +1,58 @@
+import { LitElement } from 'lit';
+import { ChipSize, ChipColor, ChipVariant, ChipRounded, ChipIconPosition, ChipCssClass, ChipModelEventDetail } from './chip-types.js';
+import { Constructor } from '../../composables/hybird-prop';
+type ChipLikeElement = HTMLSpanElement | HTMLAnchorElement;
+/** Public + shared-protected surface added by the core mixin. */
+export declare class MonoChipCoreInterface {
+    size: ChipSize;
+    color: ChipColor;
+    variant: ChipVariant;
+    rounded?: ChipRounded;
+    label?: string;
+    dot: boolean;
+    removable: boolean;
+    clickable: boolean;
+    disabled: boolean;
+    modelValue: boolean;
+    selected: boolean;
+    href?: string;
+    target?: string;
+    iconPosition: ChipIconPosition;
+    ariaLabelText?: string;
+    closeLabel: string;
+    cssClass: ChipCssClass;
+    focus(): void;
+    blur(): void;
+    click(): void;
+    protected _isActive: boolean;
+    protected _hasIcon: boolean;
+    protected _chipElement?: ChipLikeElement;
+    protected _toBoolean(value: unknown): boolean;
+    protected _cls(base: string, key: keyof ChipCssClass): string;
+    protected get _chipClasses(): string;
+    protected get _isInteractive(): boolean;
+    protected _createModelDetail(args: {
+        modelValue: boolean;
+        oldValue: boolean;
+        sourceEvent?: Event;
+    }): ChipModelEventDetail;
+    protected _handleClick(event: MouseEvent): void;
+    protected _handleKeyDown(event: KeyboardEvent): void;
+    protected _handleFocus(): void;
+    protected _handleBlur(): void;
+    protected _handleClose(event: MouseEvent): void;
+}
+/**
+ * `MonoChipCore` — all render-mode-agnostic logic for `mono-chip`: reactive
+ * props, hybrid aliases (incl. the `ariaLabel`/`aria-label`/`arialabel` →
+ * `ariaLabelText` getters), camelCase attribute fallbacks, the `modelValue`↔
+ * `selected` sync + SSR boolean coercion in `willUpdate`, class computation,
+ * click/keyboard/close interactivity (`mno-click`/`mno-close`), and the imperative
+ * `focus/blur/click`. No `render()` — the light build keeps its `[data-mono-slot]`
+ * capture strategy and the shadow build uses native `<slot>` (mirrors `mono-button`).
+ *
+ * SSR-safe: no `document`/`window` access; `_chipElement` (`@query`) is lazy and
+ * `focus/blur/click` only run client-side.
+ */
+export declare const MonoChipCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoChipCoreInterface> & T;
+export {};

package/dist/src/components/chip/chip-types.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Chip Component Type Definitions
+ */
+export type ChipSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+export type ChipColor = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'teal' | 'purple' | 'neutral' | 'dark';
+export type ChipVariant = 'soft' | 'solid' | 'outline';
+export type ChipRounded = 'none' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl' | 'full';
+export type ChipIconPosition = 'left' | 'right';
+/**
+ * How a field that holds many chips (`mono-tag-input`, `mono-dropdown-table`)
+ * lays them out.
+ *
+ * - `flex` (default) — the chips wrap onto new lines, so the field grows taller
+ *   as more are selected. This is the historical behaviour.
+ * - `inline` — the chips stay on ONE line in a horizontally scrolling strip, so
+ *   the field keeps its height no matter how many are selected. The strip is
+ *   scrolled only by the `‹` / `›` buttons the field renders next to its clear
+ *   button: there is no scrollbar, and wheel / drag / arrow-key scrolling are
+ *   all deliberately inert.
+ *
+ * `inline` also turns OFF the `max` "+N more" overflow chip — scrolling is the
+ * overflow mechanism, and running both would hide chips the strip could reach.
+ */
+export type ChipBehaviour = 'flex' | 'inline';
+/**
+ * Per-element class overrides. Each key maps to one of the rendered internal
+ * elements; the supplied class string is appended to the element's base class.
+ */
+export interface ChipCssClass {
+    root?: string;
+    main?: string;
+    content?: string;
+    label?: string;
+    dot?: string;
+    close?: string;
+}
+export interface MonoChipProps {
+    /** Sizing scale of the chip. */
+    size?: ChipSize;
+    /** Color theme applied to the chip. */
+    color?: ChipColor;
+    /** Visual style: soft, solid, or outline. */
+    variant?: ChipVariant;
+    /** Corner style: pill, rounded, or square. */
+    rounded?: ChipRounded;
+    /** Text content shown inside the chip. */
+    label?: string;
+    /** Shows a status dot before the label. */
+    dot?: boolean;
+    /** Adds a close button to remove the chip. */
+    removable?: boolean;
+    /** Disables interaction and dims the chip. */
+    disabled?: boolean;
+    /** Makes the chip clickable and toggleable. */
+    clickable?: boolean;
+    /** Two-way bound selected state of the chip. */
+    modelValue?: boolean;
+    'model-value'?: boolean;
+    modelvalue?: boolean;
+    /** Whether the chip is in the selected state. */
+    selected?: boolean;
+    /** Renders the chip as a link to this URL. */
+    href?: string;
+    /** Link target when an href is set. */
+    target?: string;
+    /**
+     * Recommended JS/TS prop.
+     */
+    iconPosition?: ChipIconPosition;
+    /**
+     * Kebab-case alias.
+     */
+    'icon-position'?: ChipIconPosition;
+    /**
+     * Lowercase fallback for static camelCase HTML.
+     */
+    iconposition?: ChipIconPosition;
+    /**
+     * Recommended JS/TS prop.
+     */
+    ariaLabelText?: string;
+    /**
+     * Shorter alias.
+     */
+    ariaLabel?: string;
+    /**
+     * Native/kebab aliases.
+     */
+    'aria-label'?: string;
+    'aria-label-text'?: string;
+    /**
+     * Lowercase fallback for static camelCase HTML.
+     */
+    arialabel?: string;
+    arialabeltext?: string;
+    /**
+     * Recommended JS/TS prop.
+     */
+    closeLabel?: string;
+    /**
+     * Kebab-case alias.
+     */
+    'close-label'?: string;
+    /**
+     * Lowercase fallback for static camelCase HTML.
+     */
+    closelabel?: string;
+    /** Per-element class overrides for internal parts. */
+    cssClass?: ChipCssClass;
+    'css-class'?: ChipCssClass;
+}
+export type StatusDotState = 'online' | 'offline' | 'busy' | 'away' | 'custom';
+export interface MonoStatusDotProps {
+    /** Status state controlling the dot's preset color. */
+    status?: StatusDotState;
+    /** Status state controlling the dot's preset color. */
+    state?: StatusDotState;
+    /** Adds a pulsing animation to the dot. */
+    pulse?: boolean;
+    /** Text label shown next to the dot. */
+    label?: string;
+    /** Custom dot color for the custom state. */
+    color?: string;
+}
+export interface ChipModelEventDetail {
+    modelValue: boolean;
+    currentValue: boolean;
+    oldValue: boolean;
+    value: boolean;
+    selected: boolean;
+    label: string;
+    sourceEvent?: Event;
+}
+export type ChipModelEvent = CustomEvent<ChipModelEventDetail>;
+export interface ChipEvents {
+    click: ChipModelEvent;
+    close: ChipModelEvent;
+    'mno-click': ChipModelEvent;
+    mnoClick: ChipModelEvent;
+    'mno-close': ChipModelEvent;
+    mnoClose: ChipModelEvent;
+}

package/dist/src/components/chip/chip-utils.d.ts

@@ -0,0 +1,24 @@
+import { ChipColor, ChipRounded, ChipSize, ChipVariant } from './chip-types.js';
+export declare function generateChipRootClasses(props: {
+    size?: ChipSize;
+    color?: ChipColor;
+    variant?: ChipVariant;
+    rounded?: ChipRounded;
+    clickable?: boolean;
+    removable?: boolean;
+    disabled?: boolean;
+    selected?: boolean;
+    dot?: boolean;
+}): string;
+export declare function isInteractive(props: {
+    clickable?: boolean;
+    href?: string;
+    removable?: boolean;
+    disabled?: boolean;
+}): boolean;
+export declare function validateChipProps(props: {
+    size?: ChipSize;
+    color?: ChipColor;
+    variant?: ChipVariant;
+    rounded?: ChipRounded;
+}): boolean;

package/dist/src/components/chip/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="../../../vue.d.ts" />
+/**
+ * Chip / Badge / Tag Component Exports
+ */
+export { MonoChip } from './mono-chip.js';
+export { MonoStatusDot } from './mono-status-dot.js';
+export type { ChipSize, ChipColor, ChipVariant, ChipRounded, ChipIconPosition, ChipCssClass, ChipModelEventDetail, ChipModelEvent, ChipEvents, MonoChipProps, MonoStatusDotProps, StatusDotState, } from './chip-types.js';
+export { generateChipRootClasses, isInteractive, validateChipProps, } from './chip-utils.js';

package/dist/src/components/chip/index.shadow.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="../../../vue.d.ts" />
+export { MonoChipShadow } from './mono-chip.shadow.js';
+export { MonoStatusDot } from './mono-status-dot.js';
+export { MonoChipCore } from './chip-core.js';
+export type { ChipSize, ChipColor, ChipVariant, ChipRounded, ChipIconPosition, ChipCssClass, ChipModelEventDetail, ChipModelEvent, ChipEvents, MonoChipProps, MonoStatusDotProps, StatusDotState, } from './chip-types.js';
+export { generateChipRootClasses, isInteractive, validateChipProps, } from './chip-utils.js';

package/dist/src/components/chip/mono-chip.d.ts

@@ -0,0 +1,48 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoChip_base: import('../../composables/hybird-prop').Constructor<import('./chip-core.js').MonoChipCoreInterface> & typeof LitElement;
+/**
+ * Light-DOM `mono-chip` (default build, `@mono-lit/helper/ui/chip`).
+ *
+ * Renders into the host (`createRenderRoot`→`this`, styled by the global
+ * `dist/ui/index.css`) with the light-DOM slot strategy: `slot="icon"`/`"close"`
+ * + default text children are captured in `connectedCallback`, the template
+ * renders empty `[data-mono-slot]` targets, and the captured nodes are re-placed
+ * in `updated()`. Capture goes through `composables/light-slots`, which carries the
+ * consumer framework's positional anchors (Vue's `<!--v-if-->` comments and
+ * zero-length Fragment text nodes) instead of deleting them, and the first render
+ * is forced **synchronously** from `connectedCallback` so capture→placement is one
+ * uninterrupted step — together that's what lets chips nest freely without crashing
+ * the consumer's next patch on a null anchor. All render-mode-agnostic logic lives
+ * in `MonoChipCore`. The shadow build (`@mono-lit/helper/ui/shadow/chip`) shares the
+ * mixin but uses native `<slot>`. Both register `mono-chip`, so a document loads
+ * only one.
+ */
+export declare class MonoChip extends MonoChip_base {
+    static styles: import('lit').CSSResult[];
+    protected createRenderRoot(): HTMLElement;
+    private _buckets;
+    private _slotsCaptured;
+    private _renderLabel;
+    private _renderDot;
+    private _renderClose;
+    private _renderContent;
+    protected render(): TemplateResult;
+    connectedCallback(): void;
+    /**
+     * In light DOM mode, <slot> elements no longer project the host's children.
+     * Capture them once before Lit's first render replaces the children, then
+     * re-place them in the render template at the right positions. `light-slots`
+     * carries comments and zero-length Fragment text nodes with the content they
+     * anchor and removes *only* what it buckets — the previous inline logic deleted
+     * every original child, dropping Vue's anchors for good.
+     */
+    private _captureSlots;
+    protected updated(changed: Map<string, unknown>): void;
+    private _placeSlot;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-chip': MonoChip;
+    }
+}
+export {};

package/dist/src/components/chip/mono-chip.shadow.d.ts

@@ -0,0 +1,33 @@
+import { LitElement, TemplateResult } from 'lit';
+declare const MonoChipShadow_base: import('../../composables/hybird-prop').Constructor<import('./chip-core.js').MonoChipCoreInterface> & typeof LitElement;
+/**
+ * Shadow-DOM `mono-chip` (the opt-in SSR build, `@mono-lit/helper/ui/shadow/chip`).
+ *
+ * Real shadow root + `static styles`, so `@lit-labs/ssr` serializes it to
+ * Declarative Shadow DOM and styles are scoped (`mono-chip`→`:host`). Slotting
+ * uses native `<slot>`: the `label` prop wins, else the default slot projects the
+ * label (DSD at parse time → no flash); `<slot name="icon">` defaults `data-empty`
+ * (hidden) so server and first client render match (corrected in `firstUpdated()`
+ * via `assignedNodes()` + `@slotchange`); the close button projects
+ * `<slot name="close">` with an inline-SVG fallback (the `i-mdi-close` UnoCSS
+ * class can't paint inside a shadow root). The icon side keys off `iconPosition`
+ * (not slot presence) so the DOM is hydration-stable. Interactivity needs the
+ * first client update to flush (so handlers bind) — hence the defer-hydration
+ * poll. Shares all logic with the light build via `MonoChipCore`; both register
+ * `mono-chip`, so a document loads only one.
+ */
+export declare class MonoChipShadow extends MonoChipShadow_base {
+    static styles: import('lit').CSSResult[];
+    connectedCallback(): void;
+    firstUpdated(changed: Map<string, unknown>): void;
+    private _iconSlot;
+    private _slotHasContent;
+    private _onIconSlotChange;
+    private _renderDot;
+    private _iconSpan;
+    private _renderLabel;
+    private _renderClose;
+    private _renderContent;
+    protected render(): TemplateResult;
+}
+export {};

package/dist/src/components/chip/mono-status-dot.d.ts

@@ -0,0 +1,34 @@
+import { LitElement, TemplateResult } from 'lit';
+import { StatusDotState } from './chip-types.js';
+/**
+ * `mono-status-dot` — a small status indicator. Already a real shadow-DOM
+ * LitElement (default render root + `static styles`, native `<slot>`), so it is
+ * SSR-compatible as-is and shared verbatim by BOTH the light (`@mono-lit/helper/ui/chip`)
+ * and shadow (`@mono-lit/helper/ui/shadow/chip`) chip builds. It lives in its own
+ * module so the shadow chip build can register it WITHOUT importing the light
+ * `mono-chip` (which would collide with the shadow `mono-chip` class).
+ *
+ * It keeps the SAME `mono-status-dot` tag in both builds (it has no light/shadow
+ * variant — it is always a shadow-DOM element), so its registration is guarded
+ * (see bottom of file): whichever chip build loads first wins, and a page that
+ * loads both light + shadow chip won't throw a "already defined" registry error.
+ */
+export declare class MonoStatusDot extends LitElement {
+    static styles: import('lit').CSSResult[];
+    constructor();
+    state: StatusDotState;
+    pulse: boolean;
+    label?: string;
+    color?: string;
+    private _statusElement?;
+    private get _statusClasses();
+    private get _statusStyle();
+    protected render(): TemplateResult;
+    focus(): void;
+    blur(): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'mono-status-dot': MonoStatusDot;
+    }
+}

package/dist/src/components/date/date-core.d.ts

@@ -0,0 +1,80 @@
+import { LitElement, TemplateResult } from 'lit';
+import { DateType, DateSize, DateColor, DateVariant, DateValidationState, DateMode, DateCssClass } from './date-types.js';
+import { Options as FlatpickrOptions } from 'flatpickr/dist/types/options';
+import { Constructor } from '../../composables/hybird-prop';
+import { CssSizeValue } from '../../composables/css-size';
+/**
+ * `MonoDateCore` — render-mode-agnostic logic for `mono-date` (props, hybrid
+ * aliases, flatpickr instance lifecycle, validation/state, and the full
+ * `render()`). SSR-safe: all DOM/`window` access (flatpickr init in
+ * `firstUpdated`, the accent read in `_onReady`) is `isServer`-guarded, so the
+ * server emits only the field markup and flatpickr is created on the client after
+ * hydration. Each build supplies `createRenderRoot()` + `static styles`. Mirrors
+ * `textarea-core`/`switch-core`.
+ *
+ * `mono-date` has no named slots — all content comes from props — so there is no
+ * slot capture/scan machinery here. The calendar popup is owned by flatpickr
+ * (appended to `<body>`, client-only, styled by the global bundle), so this needs
+ * no `PopupPortalController`/`popup-stack`.
+ */
+export declare const MonoDateCore: <T extends Constructor<LitElement>>(superClass: T) => Constructor<MonoDateCoreInterface> & T;
+/** Public surface added by the core mixin. */
+export declare class MonoDateCoreInterface {
+    type: DateType;
+    modelValue: string;
+    size: DateSize;
+    color: DateColor;
+    variant: DateVariant;
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    validationState?: DateValidationState;
+    validationMessage?: string;
+    error: boolean;
+    errorMessage?: string;
+    success: boolean;
+    successMessage?: string;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    clearable: boolean;
+    ariaLabelText?: string;
+    dateFormat?: string;
+    altInput?: boolean;
+    altFormat?: string;
+    typeable?: boolean;
+    clickOpens?: boolean;
+    defaultDate?: FlatpickrOptions['defaultDate'];
+    minDate?: FlatpickrOptions['minDate'];
+    maxDate?: FlatpickrOptions['maxDate'];
+    disable?: FlatpickrOptions['disable'];
+    enable?: FlatpickrOptions['enable'];
+    mode?: DateMode;
+    enableSeconds?: boolean;
+    time24hr?: boolean;
+    hourIncrement?: number;
+    minuteIncrement?: number;
+    defaultHour?: number;
+    defaultMinute?: number;
+    inline?: boolean;
+    weekNumbers?: boolean;
+    monthSelectorType?: 'dropdown' | 'static';
+    shorthandCurrentMonth?: boolean;
+    position?: FlatpickrOptions['position'];
+    ariaDateFormat?: string;
+    locale?: FlatpickrOptions['locale'];
+    options?: Partial<FlatpickrOptions>;
+    width?: CssSizeValue;
+    height?: CssSizeValue;
+    minWidth?: CssSizeValue;
+    maxWidth?: CssSizeValue;
+    minHeight?: CssSizeValue;
+    maxHeight?: CssSizeValue;
+    cssClass: DateCssClass;
+    cssClassName: string;
+    readonly isOpen: boolean;
+    open(): void;
+    close(): void;
+    toggle(): void;
+    protected renderIcon(name: 'calendar' | 'clock' | 'close'): TemplateResult;
+}