import * as lit_html from 'lit-html';
import * as lit from 'lit';
import { LitElement, nothing, CSSResultGroup, PropertyValues } from 'lit';
import * as Lucide from 'lucide';

type BadgeTone = "neutral" | "accent" | "success";
declare class CindorBadge extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        tone: {
            reflect: boolean;
        };
    };
    tone: BadgeTone;
    protected render(): lit_html.TemplateResult<1>;
}

type ButtonVariant = "solid" | "ghost";
type ButtonType = "button" | "submit" | "reset";
declare class CindorButton extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        iconOnly: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
        type: {
            reflect: boolean;
        };
        variant: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    iconOnly: boolean;
    type: ButtonType;
    variant: ButtonVariant;
    focus(options?: FocusOptions): void;
    click(): void;
    protected render(): lit_html.TemplateResult<1>;
    private get hostAriaDescribedBy();
    private get hostAriaLabel();
    private get hostAriaLabelledBy();
    private get buttonElement();
}

type ButtonGroupOrientation = "horizontal" | "vertical";
declare class CindorButtonGroup extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        attached: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        orientation: {
            reflect: boolean;
        };
    };
    attached: boolean;
    orientation: ButtonGroupOrientation;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleSlotChange;
    private syncGroupA11y;
    private syncItems;
    private resetItemStyles;
    private get groupElement();
    private get itemElements();
}

declare class CindorCard extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare abstract class FormAssociatedElement extends LitElement {
    static readonly formAssociated = true;
    protected internals?: ElementInternals;
    constructor();
    protected setFormValue(value: string | File | FormData | null): void;
    protected setValidityFrom(control: HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement): void;
    protected syncControlA11y(control: HTMLElement | null): void;
}

declare class CindorCalendar extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        endValue: {
            reflect: boolean;
            attribute: string;
        };
        max: {
            reflect: boolean;
        };
        min: {
            reflect: boolean;
        };
        month: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        range: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        startValue: {
            reflect: boolean;
            attribute: string;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    endValue: string;
    max: string;
    min: string;
    month: string;
    name: string;
    range: boolean;
    required: boolean;
    startValue: string;
    value: string;
    private defaultEndValue;
    private defaultMonth;
    private defaultStartValue;
    private defaultValue;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private handleDayClick;
    private showPreviousMonth;
    private showNextMonth;
    private syncMonthFromSelectionOrToday;
    private syncFormState;
    private syncSingleValueFormState;
    private syncGridA11y;
    private chunkDays;
    private buildCalendarDays;
    private get nextMonthDisabled();
    private get previousMonthDisabled();
    private get visibleMonthDate();
    private get selectionAnchorDate();
    private get selectedRange();
    private get gridElements();
    private get primarySelectedDayButton();
    private get pendingRangeStart();
    private get visibleMonths();
    private get lastVisibleMonthDate();
    private getDayPart;
    private renderMonthPanel;
}

declare class CindorCheckbox extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        checked: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    checked: boolean;
    disabled: boolean;
    name: string;
    required: boolean;
    value: string;
    private defaultChecked;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private syncFormState;
    private get inputElement();
}

type ChipTone = "neutral" | "accent" | "success";
declare class CindorChip extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        tone: {
            reflect: boolean;
        };
    };
    tone: ChipTone;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorAccordion extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    open: boolean;
    toggle(open?: boolean): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleToggle;
}

type AlertTone = "info" | "success" | "warning" | "danger";
declare class CindorAlert extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        tone: {
            reflect: boolean;
        };
    };
    tone: AlertTone;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Vertical feed for richer activity history, updates, and audit-style event streams.
 *
 * @slot - `cindor-activity-item` children.
 */
declare class CindorActivityFeed extends LitElement {
    static styles: lit.CSSResult;
    connectedCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Single event row used inside {@link CindorActivityFeed}.
 *
 * @slot leading - Leading avatar, icon, or status mark.
 * @slot title - Main activity title.
 * @slot timestamp - Time or date associated with the event.
 * @slot meta - Supplemental metadata such as actor, environment, or destination.
 * @slot actions - Optional trailing actions for the activity.
 * @slot - Main event description.
 */
declare class CindorActivityItem extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        unread: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    unread: boolean;
    connectedCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
}

type AutocompleteSuggestion = {
    description?: string;
    disabled?: boolean;
    keywords?: string[];
    label: string;
    value?: string;
};
/**
 * Suggestion-first autocomplete input for search and remote result flows.
 *
 * @fires input - Fired as the query changes.
 * @fires change - Fired when a suggestion is committed.
 * @fires suggestion-select - Fired when a suggestion is committed.
 */
declare class CindorAutocomplete extends FormAssociatedElement {
    static styles: lit.CSSResultGroup[];
    static properties: {
        activeIndex: {
            state: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        emptyMessage: {
            reflect: boolean;
            attribute: string;
        };
        loading: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        query: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        suggestions: {
            attribute: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    private static nextId;
    disabled: boolean;
    emptyMessage: string;
    loading: boolean;
    name: string;
    open: boolean;
    placeholder: string;
    query: string;
    required: boolean;
    suggestions: AutocompleteSuggestion[];
    value: string;
    private activeIndex;
    private defaultValue;
    private floatingCleanup?;
    private floatingListbox;
    private listId;
    private updateFloatingPosition?;
    connectedCallback(): void;
    disconnectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleBlur;
    private handleFocus;
    private handleInput;
    private handleKeyDown;
    private handleOptionHover;
    private handleOptionSelect;
    private commitSuggestion;
    private syncFormState;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private getOptionId;
    private getInitialActiveIndex;
    private getNextActiveIndex;
    private get filteredSuggestions();
    private get activeDescendantId();
    private get inputElement();
    private get panelElement();
    private get panelVisible();
    private get renderedOptions();
}

declare class CindorAvatar extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        alt: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        src: {
            reflect: boolean;
        };
    };
    alt: string;
    name: string;
    src: string;
    protected render(): lit_html.TemplateResult<1>;
    private get initials();
}

/**
 * Term-and-value pair used inside {@link CindorDescriptionList}.
 *
 * @slot term - Label for the value.
 * @slot - Value content.
 */
declare class CindorDescriptionItem extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Key-value description list for metadata and detail pages.
 *
 * @slot - `cindor-description-item` children.
 */
declare class CindorDescriptionList extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorDivider extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorDialog extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        modal: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    modal: boolean;
    open: boolean;
    private ignoreDialogClose;
    private presentedModal;
    focus(options?: FocusOptions): void;
    close(returnValue?: string): void;
    show(): void;
    showModal(): void;
    protected firstUpdated(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private handleCancel;
    private handleClose;
    private handleDismiss;
    private syncOpenState;
    private get dialogElement();
    private get hostAriaDescribedBy();
    private get hostAriaLabel();
    private get hostAriaLabelledBy();
}

type DrawerSide = "start" | "end";
declare class CindorDrawer extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        side: {
            reflect: boolean;
        };
    };
    open: boolean;
    side: DrawerSide;
    private previousFocusedElement;
    close: () => void;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    protected render(): lit_html.TemplateResult<1> | typeof nothing;
    private handlePanelKeyDown;
    private get hostAriaDescribedBy();
    private get hostAriaLabel();
    private get hostAriaLabelledBy();
    private get focusableElements();
    private get panelElement();
}

declare class CindorDropdownMenu extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    open: boolean;
    private floatingCleanup?;
    private floatingMenu;
    private updateFloatingPosition?;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    disconnectedCallback(): void;
    private handleToggle;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private syncMenuA11y;
    private get menuElement();
    private get triggerElement();
    private handleItemSelect;
    private get detailsElement();
}

declare class CindorDropzone extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        accept: {
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        dragActive: {
            state: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    accept: string;
    disabled: boolean;
    multiple: boolean;
    name: string;
    required: boolean;
    private dragActive;
    private selectedFiles;
    private selectedFilesList;
    checkValidity(): boolean;
    get files(): FileList | null;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleInput;
    private handleChange;
    private handleTriggerClick;
    private handleDragEnter;
    private handleDragOver;
    private handleDragLeave;
    private handleDrop;
    private captureInputFiles;
    private captureFiles;
    private syncFormState;
    private syncInputFiles;
    private get inputElement();
    private get triggerElement();
}

declare class CindorBreadcrumbs extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorCodeBlock extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        code: {
            reflect: boolean;
        };
        language: {
            reflect: boolean;
        };
    };
    code: string;
    language: string;
    private slotCode;
    connectedCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleSlotChange;
    private get sourceCode();
    private get highlightedCode();
}

declare class CindorColorInput extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    name: string;
    value: string;
    private defaultValue;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private syncFormState;
    private get inputElement();
    private handleTriggerClick;
}

declare class CindorCombobox extends FormAssociatedElement {
    static styles: lit.CSSResultGroup[];
    static properties: {
        activeIndex: {
            state: boolean;
        };
        autocomplete: {
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        open: {
            state: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    private static nextId;
    autocomplete: string;
    disabled: boolean;
    name: string;
    open: boolean;
    placeholder: string;
    readonly: boolean;
    required: boolean;
    value: string;
    private activeIndex;
    private defaultValue;
    private floatingCleanup?;
    private floatingListbox;
    private listId;
    private optionNodes;
    private updateFloatingPosition?;
    connectedCallback(): void;
    disconnectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private handleFocus;
    private handleBlur;
    private handleKeyDown;
    private handleSlotChange;
    private refreshOptions;
    private commitOption;
    private syncFormState;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private get inputElement();
    private get listboxElement();
    private get filteredOptions();
    private get listboxVisible();
    private get activeDescendantId();
    private getInitialActiveIndex;
    private getOptionId;
    private handleOptionHoverEvent;
    private handleOptionSelect;
    private get renderedOptionElements();
    private getNextActiveIndex;
}

/**
 * Persistent contextual action bar for bulk actions and page-level commands.
 *
 * @slot - Optional supporting content shown with the summary copy.
 * @slot actions - Action controls rendered on the trailing edge.
 */
declare class CindorCommandBar extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        count: {
            type: NumberConstructor;
            reflect: boolean;
        };
        countLabel: {
            reflect: boolean;
            attribute: string;
        };
        description: {
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        sticky: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    count: number;
    countLabel: string;
    description: string;
    label: string;
    sticky: boolean;
    protected render(): lit_html.TemplateResult<1>;
    private get accessibleLabel();
}

type CommandPaletteCommand = {
    description?: string;
    disabled?: boolean;
    keywords?: string[];
    label: string;
    shortcut?: string;
    value: string;
};
declare class CindorCommandPalette extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        commands: {
            attribute: boolean;
        };
        emptyMessage: {
            reflect: boolean;
            attribute: string;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        query: {
            reflect: boolean;
        };
        title: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    commands: CommandPaletteCommand[];
    emptyMessage: string;
    open: boolean;
    placeholder: string;
    query: string;
    title: string;
    value: string;
    private activeIndex;
    private focusSearchOnOpen;
    close(): void;
    show(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private handleCancel;
    private handleClose;
    private handleInput;
    private handleKeyDown;
    private handleOptionSelect;
    private normalizeActiveIndex;
    private selectCommand;
    private get filteredCommands();
    private get searchElement();
}

/**
 * Right-click menu surface that composes Cindor menu primitives.
 *
 * @fires toggle - Fired when the menu opens or closes.
 *
 * @slot trigger - Element that receives context menu and keyboard-open interaction.
 * @slot - `cindor-menu-item` children rendered inside the menu.
 */
declare class CindorContextMenu extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    open: boolean;
    private anchorX;
    private anchorY;
    private restoreFocusTarget;
    connectedCallback(): void;
    disconnectedCallback(): void;
    close(): void;
    openAt(x: number, y: number): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<string, unknown>): void;
    private handleContextMenu;
    private handleTriggerKeydown;
    private handleMenuItemSelect;
    private handleMenuKeydown;
    private handleDocumentPointerDown;
    private handleWindowBlur;
    private handleViewportChange;
    private positionMenu;
    private syncMenuA11y;
    private focusFirstItem;
    private dispatchToggleEvent;
    private get menuElement();
    private get triggerElement();
}

/**
 * Popup date picker that reuses the Cindor calendar surface.
 *
 * @fires input - Fired when the selected date changes.
 * @fires change - Fired when the selected date changes.
 * @fires toggle - Fired when the popup opens or closes.
 */
declare class CindorDatePicker extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        max: {
            reflect: boolean;
        };
        min: {
            reflect: boolean;
        };
        month: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    max: string;
    min: string;
    month: string;
    name: string;
    open: boolean;
    placeholder: string;
    required: boolean;
    value: string;
    private defaultValue;
    private floatingCleanup?;
    private floatingPanel;
    private updateFloatingPosition?;
    connectedCallback(): void;
    disconnectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    show(): void;
    close(): void;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private handleFieldClick;
    private handleFieldKeyDown;
    private handleToggleClick;
    private handleClear;
    private handleCalendarInput;
    private handleCalendarChange;
    private handleDocumentPointerDown;
    private syncFormState;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private dispatchToggle;
    private get fieldElement();
    private get inputElement();
    private get panelElement();
}

/**
 * Popup date range picker powered by the Cindor range calendar.
 *
 * @fires input - Fired as the selected range changes.
 * @fires change - Fired when a range selection completes.
 * @fires toggle - Fired when the popup opens or closes.
 */
declare class CindorDateRangePicker extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        endValue: {
            reflect: boolean;
            attribute: string;
        };
        max: {
            reflect: boolean;
        };
        min: {
            reflect: boolean;
        };
        month: {
            reflect: boolean;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        startValue: {
            reflect: boolean;
            attribute: string;
        };
    };
    endValue: string;
    max: string;
    min: string;
    month: string;
    open: boolean;
    placeholder: string;
    startValue: string;
    private floatingCleanup?;
    private floatingPanel;
    private updateFloatingPosition?;
    connectedCallback(): void;
    disconnectedCallback(): void;
    show(): void;
    close(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleFieldClick;
    private handleFieldKeyDown;
    private handleToggleClick;
    private handleClear;
    private handleCalendarInput;
    private handleCalendarChange;
    private handleDocumentPointerDown;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private dispatchToggle;
    private get fieldElement();
    private get panelElement();
    private get rangeSummary();
}

/**
 * Combined date and time picker built from Cindor date and time fields.
 *
 * @fires input - Fired when either the date or time value changes.
 * @fires change - Fired when the combined value changes.
 */
declare class CindorDateTimePicker extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        dateValue: {
            reflect: boolean;
            attribute: string;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        timeValue: {
            reflect: boolean;
            attribute: string;
        };
        value: {
            reflect: boolean;
        };
    };
    dateValue: string;
    disabled: boolean;
    name: string;
    required: boolean;
    timeValue: string;
    value: string;
    private defaultValue;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private handleDateInput;
    private handleDateChange;
    private handleTimeInput;
    private handleTimeChange;
    private syncSplitValues;
    private syncCombinedValue;
    private syncFormState;
    private get datePickerElement();
}

declare class BaseInputElement extends FormAssociatedElement {
    static styles: CSSResultGroup;
    static properties: {
        autocomplete: {
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        endIcon: {
            reflect: boolean;
            attribute: string;
        };
        max: {
            reflect: boolean;
        };
        min: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        startIcon: {
            reflect: boolean;
            attribute: string;
        };
        step: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    autocomplete: string;
    disabled: boolean;
    endIcon: string;
    max: string;
    min: string;
    name: string;
    placeholder: string;
    readonly: boolean;
    required: boolean;
    startIcon: string;
    step: string;
    value: string;
    protected defaultValue: string;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    protected handleChange: (event: Event) => void;
    protected handleInput: (event: InputEvent) => void;
    protected syncFormState(): void;
    protected get inputElement(): HTMLInputElement | null;
    protected get hasStartAdornment(): boolean;
    protected get hasEndAdornment(): boolean;
    protected renderStartAdornment(): lit_html.TemplateResult<1> | typeof nothing;
    protected renderEndAdornment(): lit_html.TemplateResult<1> | typeof nothing;
    protected get inputType(): string;
}
declare class CindorInput extends BaseInputElement {
    static properties: {
        type: {
            reflect: boolean;
        };
        autocomplete: {
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        endIcon: {
            reflect: boolean;
            attribute: string;
        };
        max: {
            reflect: boolean;
        };
        min: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        startIcon: {
            reflect: boolean;
            attribute: string;
        };
        step: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    type: string;
    protected get inputType(): string;
}

declare class CindorDateInput extends BaseInputElement {
    protected get inputType(): string;
}

type DataTableRow = Record<string, unknown>;
type DataTableSortDirection = "ascending" | "descending";
type DataTableCellAlign = "center" | "end" | "start";
type DataTableCellRenderDetail = {
    column: DataTableColumn;
    row: DataTableRow;
    rowId: string;
    rowIndex: number;
    table: CindorDataTable;
    value: unknown;
};
type DataTableSortComparator = (leftValue: unknown, rightValue: unknown, detail: {
    column: DataTableColumn;
    leftRow: DataTableRow;
    rightRow: DataTableRow;
    table: CindorDataTable;
}) => number;
type DataTableSortValueAccessor = (row: DataTableRow, detail: {
    column: DataTableColumn;
    rowIndex: number;
    table: CindorDataTable;
}) => unknown;
type DataTableTooltipText = boolean | string | ((detail: DataTableCellRenderDetail) => string | null | undefined);
type DataTableEditorOption = {
    label: string;
    value: string;
};
type DataTableEditorDisablePredicate = boolean | ((detail: DataTableCellRenderDetail) => boolean);
type DataTableCellEditor = {
    autocomplete?: string;
    disabled?: DataTableEditorDisablePredicate;
    placeholder?: string;
    type: "input";
} | {
    disabled?: DataTableEditorDisablePredicate;
    options: DataTableEditorOption[] | ((detail: DataTableCellRenderDetail) => DataTableEditorOption[]);
    type: "select";
} | {
    disabled?: DataTableEditorDisablePredicate;
    type: "switch";
};
type DataTableRowAction = {
    disabled?: boolean | ((detail: DataTableCellRenderDetail) => boolean);
    icon?: string;
    key: string;
    label: string;
    variant?: "ghost" | "solid";
};
type DataTableColumn = {
    actions?: DataTableRowAction[];
    align?: DataTableCellAlign;
    cellRenderer?: (detail: DataTableCellRenderDetail) => unknown;
    cellSlot?: string;
    editor?: DataTableCellEditor;
    key: string;
    label: string;
    numeric?: boolean;
    sortable?: boolean;
    sortComparator?: DataTableSortComparator;
    sortValue?: DataTableSortValueAccessor;
    tooltip?: DataTableTooltipText;
    truncate?: boolean;
    width?: string;
};
/**
 * Searchable, sortable application data table built from native table semantics.
 *
 * @summary Searchable, sortable data table for application records.
 * @tag cindor-data-table
 * @fires {CustomEvent<DataTableCellEditDetail>} cell-edit - Fired when an inline editor updates a row value.
 * @fires {CustomEvent<DataTablePageChangeDetail>} page-change - Fired when the current page changes through pagination.
 * @fires {CustomEvent<DataTableRowActionDetail>} row-action - Fired when a row action button is pressed.
 * @fires {CustomEvent<DataTableSearchChangeDetail>} search-change - Fired when the search query changes and the matching row count updates.
 * @fires {CustomEvent<{ sortDirection: DataTableSortDirection; sortKey: string }>} sort-change - Fired when the active sort column or direction changes.
 */
declare class CindorDataTable extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        caption: {
            reflect: boolean;
        };
        columns: {
            attribute: boolean;
        };
        currentPage: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
        emptyMessage: {
            reflect: boolean;
            attribute: string;
        };
        loading: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        pageSize: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
        rowIdKey: {
            reflect: boolean;
            attribute: string;
        };
        rows: {
            attribute: boolean;
        };
        searchable: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        searchLabel: {
            reflect: boolean;
            attribute: string;
        };
        searchPlaceholder: {
            reflect: boolean;
            attribute: string;
        };
        searchQuery: {
            reflect: boolean;
            attribute: string;
        };
        sortDirection: {
            reflect: boolean;
            attribute: string;
        };
        sortKey: {
            reflect: boolean;
            attribute: string;
        };
    };
    caption: string;
    columns: DataTableColumn[];
    currentPage: number;
    emptyMessage: string;
    loading: boolean;
    pageSize: number;
    rowIdKey: string;
    rows: DataTableRow[];
    searchable: boolean;
    searchLabel: string;
    searchPlaceholder: string;
    searchQuery: string;
    sortDirection: DataTableSortDirection;
    sortKey: string;
    protected willUpdate(changedProperties: PropertyValues<this>): void;
    protected render(): lit_html.TemplateResult<1>;
    private renderCell;
    private renderCellContent;
    private renderActionButton;
    private renderCellEditor;
    private handleTextEditorChange;
    private handleSelectEditorChange;
    private handleSwitchEditorChange;
    private commitCellEdit;
    private handleRowAction;
    private createCellDetail;
    private getCellSlotName;
    private getTooltipText;
    private resolveEditorDisabled;
    private resolveActionDisabled;
    private normalizeTextValue;
    private formatCellValue;
    private handleSearchInput;
    private handlePaginationChange;
    private summaryText;
    private toggleSort;
    private setCurrentPage;
    private get filteredRows();
    private getSearchValue;
    private get sortedRows();
    private defaultSortComparison;
    private get visibleRows();
    private get normalizedPageSize();
    private get paginationEnabled();
    private get totalPages();
    private get clampedCurrentPage();
    private getRowIndex;
    private getRowId;
    private columnAlign;
    private columnWidthStyle;
    private cellContentStyle;
}

declare class CindorEmailInput extends BaseInputElement {
    autocomplete: string;
    protected get inputType(): string;
}

declare class CindorErrorText extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorEmptyState extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Search-specific zero-state messaging with optional suggestions and actions.
 *
 * @slot - Optional guidance or search tips shown below the main copy.
 * @slot media - Optional custom leading media.
 * @slot actions - Action controls for retry or broaden-search flows.
 */
declare class CindorEmptySearchResults extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        description: {
            reflect: boolean;
        };
        heading: {
            reflect: boolean;
        };
        query: {
            reflect: boolean;
        };
    };
    description: string;
    heading: string;
    query: string;
    protected render(): lit_html.TemplateResult<1>;
    private get message();
}

declare class CindorFieldset extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        legend: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    legend: string;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorForm extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        description: {
            reflect: boolean;
        };
        error: {
            reflect: boolean;
        };
        submitting: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        submittingLabel: {
            reflect: boolean;
            attribute: string;
        };
        success: {
            reflect: boolean;
        };
        validateOnSubmit: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
    };
    description: string;
    error: string;
    submitting: boolean;
    submittingLabel: string;
    success: string;
    validateOnSubmit: boolean;
    private autoError;
    private currentForm;
    private invalidFields;
    private readonly managedDisabledElements;
    connectedCallback(): void;
    disconnectedCallback(): void;
    checkValidity(): boolean;
    reportValidity(): boolean;
    requestSubmit(submitter?: HTMLElement): void;
    reset(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<string, unknown>): void;
    private handleControlInteraction;
    private handleInvalid;
    private handleReset;
    private handleSlotChange;
    private handleSubmit;
    private attachForm;
    private clearFieldValidationErrors;
    private clearValidationState;
    private collectInvalidFields;
    private detachForm;
    private getControlLabel;
    private getEventControl;
    private getFieldLabel;
    private getManagedFields;
    private getOwningField;
    private getValidatableControls;
    private getValidationMessage;
    private getValidationTarget;
    private checkControlValidity;
    private refreshValidationSummary;
    private releaseManagedDisabledState;
    private reportControlValidity;
    private syncFieldValidation;
    private syncSubmittingState;
    private get formElement();
    private isDisableCapableElement;
}

declare class CindorFileInput extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        accept: {
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        multiple: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    accept: string;
    disabled: boolean;
    multiple: boolean;
    name: string;
    required: boolean;
    checkValidity(): boolean;
    get files(): FileList | null;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleInput;
    private handleChange;
    private syncFormState;
    private get inputElement();
    private handleTriggerClick;
}

type FilterBuilderLogic = "and" | "or";
type FilterBuilderFieldType = "text" | "number" | "date" | "select" | "boolean";
type FilterBuilderOption = {
    label: string;
    value: string;
};
type FilterBuilderOperator = {
    label: string;
    value: string;
};
type FilterBuilderField = {
    label: string;
    operators?: FilterBuilderOperator[];
    options?: FilterBuilderOption[];
    placeholder?: string;
    type?: FilterBuilderFieldType;
    value: string;
};
type FilterBuilderRule = {
    field: string;
    id: string;
    operator: string;
    type: "rule";
    value: string;
};
type FilterBuilderGroup = {
    children: FilterBuilderNode[];
    id: string;
    logic: FilterBuilderLogic;
    type: "group";
};
type FilterBuilderNode = FilterBuilderRule | FilterBuilderGroup;
/**
 * Rule and group based filtering UI built from native fieldset, select, and input controls.
 *
 * The serialized `value` property stores the current filter group as JSON.
 *
 * @fires {CustomEvent<FilterBuilderChangeDetail>} input - Fired when the serialized filter value changes.
 * @fires {CustomEvent<FilterBuilderChangeDetail>} change - Fired when the serialized filter value changes.
 */
declare class CindorFilterBuilder extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        fields: {
            attribute: boolean;
        };
        name: {
            reflect: boolean;
        };
        value: {};
    };
    disabled: boolean;
    fields: FilterBuilderField[];
    name: string;
    value: string;
    private group;
    private idCounter;
    connectedCallback(): void;
    formDisabledCallback(disabled: boolean): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<string, unknown>): void;
    private renderGroup;
    private renderRule;
    private renderValueControl;
    private handleRuleFieldChange;
    private handleRuleOperatorChange;
    private handleRuleValueChange;
    private updateGroupLogic;
    private addRule;
    private addGroup;
    private removeNode;
    private commitGroup;
    private dispatchValueEvents;
    private syncFormState;
    private updateGroupAtPath;
    private updateRuleAtPath;
    private removeNodeAtPath;
    private createDefaultGroup;
    private createDefaultRule;
    private normalizeGroup;
    private normalizeRule;
    private normalizeRuleValue;
    private getDefaultValue;
    private getField;
    private getFieldType;
    private getOperators;
    private parseValue;
    private serializeGroup;
    private createId;
}

declare class CindorFormField extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        description: {
            reflect: boolean;
        };
        error: {
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        validationError: {
            attribute: boolean;
        };
    };
    private static nextId;
    description: string;
    error: string;
    label: string;
    required: boolean;
    validationError: string;
    private readonly fieldId;
    private hasDescriptionSlot;
    private hasErrorSlot;
    private hasLabelSlot;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleControlSlotChange;
    private handleDescriptionSlotChange;
    private handleErrorSlotChange;
    private handleLabelSlotChange;
    private syncControlAssociations;
    private getAssignedElements;
    private syncManagedTokens;
    private isLabelableControl;
    private get controlElement();
    private get descriptionId();
    private get errorId();
    private get labelId();
}

declare class CindorFormRow extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        columns: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    columns: number;
    protected render(): lit_html.TemplateResult<1>;
    private get normalizedColumns();
}

declare class CindorHelperText extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare const lucideIcons: Readonly<Record<string, Lucide.IconNode>>;
type LucideIconName = keyof typeof lucideIcons;

declare class CindorIcon extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        label: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        size: {
            type: NumberConstructor;
            reflect: boolean;
        };
        strokeWidth: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
    };
    label: string;
    name: LucideIconName | string;
    size: number;
    strokeWidth: number;
    protected render(): lit_html.TemplateResult<1> | typeof lit_html.nothing;
}

declare class CindorIconButton extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        size: {
            type: NumberConstructor;
            reflect: boolean;
        };
        strokeWidth: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
        type: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    label: string;
    name: string;
    size: number;
    strokeWidth: number;
    type: ButtonType;
    focus(options?: FocusOptions): void;
    click(): void;
    protected render(): lit_html.TemplateResult<1>;
    private get buttonElement();
    private get hostAriaDescribedBy();
    private get hostAriaLabel();
    private get hostAriaLabelledBy();
}

/**
 * Inline text editing surface for titles, labels, and small editable values.
 *
 * @fires input - Fired while the draft value changes.
 * @fires change - Fired when the saved value changes.
 * @fires cancel - Fired when editing is cancelled.
 * @fires toggle - Fired when editing starts or stops.
 */
declare class CindorInlineEdit extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        editing: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    editing: boolean;
    placeholder: string;
    value: string;
    private draftValue;
    beginEdit(): void;
    cancelEdit(): void;
    save(): void;
    focus(options?: FocusOptions): void;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleBeginEdit;
    private handleCancel;
    private handleInput;
    private handleKeyDown;
    private handleSave;
    private dispatchToggle;
    private get editButton();
    private get inputElement();
}

/**
 * Vertical layout container for page and workflow composition.
 *
 * @slot - Layout regions such as `cindor-layout-header`, `cindor-layout-content`, or adjacent primitives.
 */
declare class CindorLayout extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Main content region for page sections, forms, and data views.
 *
 * @slot - Primary content for the current layout section.
 */
declare class CindorLayoutContent extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Header region for page-level titles, controls, and supporting metadata.
 *
 * @slot - Header copy, actions, or composition primitives.
 */
declare class CindorLayoutHeader extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorListbox extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        activeIndex: {
            type: NumberConstructor;
            attribute: string;
        };
        multiselectable: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        selectedValue: {
            attribute: string;
        };
    };
    activeIndex: number;
    multiselectable: boolean;
    selectedValue?: string;
    connectedCallback(): void;
    protected updated(): void;
    protected render(): lit_html.TemplateResult<1>;
    private get optionElements();
}

declare class CindorLink extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        download: {
            reflect: boolean;
        };
        href: {
            reflect: boolean;
        };
        rel: {
            reflect: boolean;
        };
        target: {
            reflect: boolean;
        };
    };
    download: string;
    href: string;
    rel: string;
    target: string;
    click(): void;
    focus(options?: FocusOptions): void;
    protected render(): lit_html.TemplateResult<1>;
    private get anchorElement();
    private get resolvedRel();
}

declare class CindorMeter extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        high: {
            type: NumberConstructor;
            reflect: boolean;
        };
        low: {
            type: NumberConstructor;
            reflect: boolean;
        };
        max: {
            type: NumberConstructor;
            reflect: boolean;
        };
        min: {
            type: NumberConstructor;
            reflect: boolean;
        };
        optimum: {
            type: NumberConstructor;
            reflect: boolean;
        };
        value: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    high: number;
    low: number;
    max: number;
    min: number;
    optimum: number;
    value: number;
    protected render(): lit_html.TemplateResult<1>;
}

declare class CindorMenu extends LitElement {
    static styles: lit.CSSResult;
    connectedCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleKeyDown;
    private get menuItems();
}

declare class CindorMenuItem extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    disabled: boolean;
    connectedCallback(): void;
    click(): void;
    focus(options?: FocusOptions): void;
    protected updated(): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleClick;
    private get buttonElement();
}

/**
 * Horizontal application menubar with roving keyboard focus.
 *
 * @slot - Menubar commands or links.
 */
declare class CindorMenubar extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleKeyDown;
    private handleSlotChange;
    private syncA11y;
    private focusItem;
    private collectItems;
    private isDisabled;
    private get menubarElement();
    private get menubarItems();
}

declare class CindorNumberInput extends BaseInputElement {
    protected get inputType(): string;
}

/**
 * Searchable multi-select built from Cindor listbox and option primitives.
 *
 * Use light-DOM `option` or `cindor-option` children as the source option set.
 *
 * @fires input - Fired when the selected values change.
 * @fires change - Fired when the selected values change.
 *
 * @slot - `option` or `cindor-option` children that define the available choices.
 */
declare class CindorMultiSelect extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        activeIndex: {
            state: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        query: {
            state: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        values: {
            attribute: boolean;
        };
    };
    private static nextId;
    disabled: boolean;
    name: string;
    open: boolean;
    placeholder: string;
    required: boolean;
    values: string[];
    private activeIndex;
    private defaultValues;
    private floatingCleanup?;
    private floatingListbox;
    private initializedValues;
    private listId;
    private optionNodes;
    private query;
    private updateFloatingPosition?;
    connectedCallback(): void;
    disconnectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<string, unknown>): void;
    private handleBlur;
    private handleControlPointerDown;
    private handleFocus;
    private handleInput;
    private handleKeyDown;
    private handleOptionHoverEvent;
    private handleOptionSelect;
    private handleSlotChange;
    private refreshOptions;
    private commitOption;
    private removeValue;
    private dispatchValueEvents;
    private syncFormState;
    private syncValidity;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private syncLightDomSelection;
    private normalizedValues;
    private isSelected;
    private getOptionId;
    private getInitialActiveIndex;
    private getNextActiveIndex;
    private get filteredOptions();
    private get selectedOptions();
    private get listboxVisible();
    private get activeDescendantId();
    private get inputElement();
    private get isValueMissing();
    private get listboxElement();
    private get renderedOptionElements();
}

/**
 * Vertical navigation rail for compact app-shell layouts.
 *
 * @slot - `cindor-navigation-rail-item` children.
 */
declare class CindorNavigationRail extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleKeyDown;
    private handleSlotChange;
    private syncA11y;
    private get railElement();
    private get railItems();
}

/**
 * Compact icon-and-label row used inside {@link CindorNavigationRail}.
 *
 * @slot start - Leading icon or badge.
 * @slot - Optional label content.
 */
declare class CindorNavigationRailItem extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        current: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        href: {
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        rel: {
            reflect: boolean;
        };
        target: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    current: boolean;
    disabled: boolean;
    href: string;
    label: string;
    rel: string;
    target: string;
    value: string;
    click(): void;
    focus(options?: FocusOptions): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleClick;
    private handleLinkClick;
    private get controlElement();
}

declare class CindorOption extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        active: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        selected: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    active: boolean;
    disabled: boolean;
    label: string;
    selected: boolean;
    value: string;
    connectedCallback(): void;
    click(): void;
    protected updated(): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleClick;
    private handleMouseDown;
    private handleMouseMove;
    private get surfaceElement();
}

declare class CindorPagination extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        currentPage: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
        maxVisiblePages: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
        totalPages: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
    };
    currentPage: number;
    maxVisiblePages: number;
    totalPages: number;
    protected render(): lit_html.TemplateResult<1>;
    private selectPage;
    private goToNextPage;
    private goToPreviousPage;
    private get items();
    private get lastPage();
}

declare class CindorPasswordInput extends BaseInputElement {
    static styles: CSSResultGroup;
    static properties: {
        revealPassword: {
            state: boolean;
        };
        autocomplete: {
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        endIcon: {
            reflect: boolean;
            attribute: string;
        };
        max: {
            reflect: boolean;
        };
        min: {
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        startIcon: {
            reflect: boolean;
            attribute: string;
        };
        step: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    autocomplete: string;
    private revealPassword;
    private handleToggleClick;
    protected get hasEndAdornment(): boolean;
    protected renderEndAdornment(): lit_html.TemplateResult<1>;
    protected get inputType(): string;
}

/**
 * Reusable page header with breadcrumbs, metadata, and page-level actions.
 *
 * @slot - Optional supporting content rendered below the main heading row.
 * @slot breadcrumbs - Optional breadcrumb or parent-navigation content.
 * @slot meta - Optional metadata such as badges or supporting facts.
 * @slot actions - Optional trailing actions such as buttons or segmented controls.
 */
declare class CindorPageHeader extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        description: {
            reflect: boolean;
        };
        eyebrow: {
            reflect: boolean;
        };
        title: {
            reflect: boolean;
        };
    };
    description: string;
    eyebrow: string;
    title: string;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Reusable details panel surface for inspector, properties, and supplemental context.
 *
 * @slot - Main panel body content.
 * @slot actions - Optional trailing header actions.
 * @slot footer - Optional footer content such as buttons or summaries.
 * @slot meta - Optional metadata shown below the title copy.
 */
declare class CindorPanelInspector extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        description: {
            reflect: boolean;
        };
        sticky: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        title: {
            reflect: boolean;
        };
    };
    description: string;
    sticky: boolean;
    title: string;
    protected render(): lit_html.TemplateResult<1>;
    private get accessibleLabel();
}

declare class CindorPopover extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    open: boolean;
    private floatingCleanup?;
    private floatingPanel;
    private updateFloatingPosition?;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    disconnectedCallback(): void;
    private handleToggle;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private get panelElement();
    private get triggerElement();
}

declare class CindorProgress extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        max: {
            type: NumberConstructor;
            reflect: boolean;
        };
        value: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    max: number;
    value: number;
    protected render(): lit_html.TemplateResult<1>;
    private get normalizedMax();
    private get clampedValue();
}

type ProviderTheme = "inherit" | "light" | "dark";
type ProviderColorScheme = "inherit" | "light" | "dark";
/**
 * Lightweight theme scope for Cindor tokens and descendant components.
 *
 * @slot - Descendant application or component content.
 */
declare class CindorProvider extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        colorScheme: {
            attribute: string;
            reflect: boolean;
        };
        theme: {
            reflect: boolean;
        };
    };
    colorScheme: ProviderColorScheme;
    theme: ProviderTheme;
    connectedCallback(): void;
    protected updated(): void;
    protected render(): lit_html.TemplateResult<1>;
    private syncPresentation;
}

declare class CindorRadio extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        checked: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    checked: boolean;
    disabled: boolean;
    name: string;
    required: boolean;
    value: string;
    private defaultChecked;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private syncFormState;
    private get inputElement();
}

declare class CindorRange extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        max: {
            type: NumberConstructor;
            reflect: boolean;
        };
        min: {
            type: NumberConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        step: {
            type: NumberConstructor;
            reflect: boolean;
        };
        value: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    disabled: boolean;
    max: number;
    min: number;
    name: string;
    required: boolean;
    step: number;
    value: number;
    private defaultValue;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleInput;
    private handleChange;
    private syncFormState;
    private get inputElement();
}

declare class CindorRatingInput extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        clearable: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        max: {
            type: NumberConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    private static nextId;
    clearable: boolean;
    disabled: boolean;
    max: number;
    name: string;
    required: boolean;
    value: number;
    private defaultValue;
    private groupId;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private handleClearClick;
    private syncFormState;
    private syncGroupA11y;
    private get groupElement();
    private get inputElements();
}

declare class CindorSearch extends BaseInputElement {
    startIcon: string;
    protected get inputType(): string;
}

type SkeletonVariant = "line" | "block" | "circle";
declare class CindorSkeleton extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        variant: {
            reflect: boolean;
        };
    };
    variant: SkeletonVariant;
    protected render(): lit_html.TemplateResult<1>;
}

type SegmentedControlOption = {
    disabled?: boolean;
    label: string;
    value: string;
};
declare class CindorSegmentedControl extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        options: {
            attribute: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    private static nextId;
    disabled: boolean;
    name: string;
    options: SegmentedControlOption[];
    required: boolean;
    value: string;
    private defaultValue;
    private groupId;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private handleChange;
    private handleInput;
    private normalizeValue;
    private syncFormState;
    private syncGroupA11y;
    private get groupElement();
    private get inputElements();
}

declare class CindorSelect extends FormAssociatedElement {
    static styles: lit.CSSResultGroup[];
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    name: string;
    required: boolean;
    value: string;
    private defaultValue;
    private optionNodes;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private handleSlotChange;
    private refreshOptions;
    private syncFormState;
    private get selectElement();
}

declare class CindorSpinner extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Keyboard-accessible side navigation landmark with nested sections.
 *
 * Use direct child `cindor-side-nav-item` elements, optionally nesting them to
 * create collapsible sections.
 *
 * @slot - Direct child `cindor-side-nav-item` elements.
 */
declare class CindorSideNav extends LitElement {
    static styles: lit.CSSResult;
    private readonly itemObserver;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected firstUpdated(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleFocusIn;
    private handleKeyDown;
    private handleSlotChange;
    private handleExpandKey;
    private handleCollapseKey;
    private focusItem;
    private refreshItems;
    private syncNavA11y;
    private collectVisibleItems;
    private parentItem;
    private childItems;
    private itemControl;
    private get allItems();
    private get focusedItem();
    private get navElement();
    private get visibleItems();
}

/**
 * Navigable row used inside {@link CindorSideNav}.
 *
 * Set `href` to render the row as a link, or omit it to render a button-like
 * item that can toggle its nested children.
 *
 * @fires toggle - Fired when the expanded branch state changes.
 * @fires side-nav-select - Fired when a non-link leaf item is activated.
 *
 * @slot start - Optional leading decoration such as an icon.
 * @slot - Nested child `cindor-side-nav-item` elements.
 */
declare class CindorSideNavItem extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        current: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        expanded: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        href: {
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        rel: {
            reflect: boolean;
        };
        target: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    current: boolean;
    disabled: boolean;
    expanded: boolean;
    href: string;
    label: string;
    rel: string;
    target: string;
    value: string;
    private hasChildren;
    connectedCallback(): void;
    click(): void;
    focus(options?: FocusOptions): void;
    toggle(expanded?: boolean): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleButtonClick;
    private handleLinkClick;
    private handleSlotChange;
    private handleToggleClick;
    private dispatchToggleEvent;
    private get itemElement();
    private get nestedItems();
}

type SplitterOrientation = "horizontal" | "vertical";
/**
 * Resizable panel group for workbench-style layouts.
 *
 * @fires panel-resize - Fired whenever adjacent panel sizes change.
 *
 * @slot - Direct child `cindor-splitter-panel` elements.
 */
declare class CindorSplitter extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        orientation: {
            reflect: boolean;
        };
    };
    orientation: SplitterOrientation;
    private activeDrag;
    private readonly panelObserver;
    private panels;
    private sizes;
    private syncingPanels;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    private renderHandle;
    private handleSlotChange;
    private handlePointerDown;
    private handleWindowPointerMove;
    private handleWindowPointerUp;
    private handleHandleKeydown;
    private applyResize;
    private setSizes;
    private syncPanels;
    private coordinateFor;
    private get containerElement();
}

/**
 * Panel surface used inside {@link CindorSplitter}.
 *
 * @slot - Panel content.
 */
declare class CindorSplitterPanel extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        minSize: {
            attribute: string;
            type: NumberConstructor;
            reflect: boolean;
        };
        size: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    minSize: number;
    size: number;
    protected render(): lit_html.TemplateResult<1>;
}

type StackDirection = "vertical" | "horizontal";
type StackGap = "0" | "1" | "2" | "3" | "4" | "5" | "6";
type StackAlign = "start" | "center" | "end" | "stretch" | "baseline";
type StackJustify = "start" | "center" | "end" | "between";
/**
 * Flexible spacing primitive for stacking, clustering, and wrapped inline layouts.
 *
 * @slot - Child elements arranged by the configured flex settings.
 */
declare class CindorStack extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        align: {
            reflect: boolean;
        };
        direction: {
            reflect: boolean;
        };
        gap: {
            reflect: boolean;
        };
        justify: {
            reflect: boolean;
        };
        wrap: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    align: StackAlign;
    direction: StackDirection;
    gap: StackGap;
    justify: StackJustify;
    wrap: boolean;
    protected render(): lit_html.TemplateResult<1>;
}

type StatCardTone = "neutral" | "positive" | "negative";
/**
 * Summary metric card for dashboards and KPI surfaces.
 *
 * @slot - Optional supporting description or actions.
 */
declare class CindorStatCard extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        change: {
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        tone: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    change: string;
    label: string;
    tone: StatCardTone;
    value: string;
    protected render(): lit_html.TemplateResult<1>;
}

type StepperOrientation = "horizontal" | "vertical";
type StepperStatus = "complete" | "current" | "upcoming" | "error";
type StepperStep = {
    description?: string;
    disabled?: boolean;
    label: string;
    optional?: boolean;
    status?: StepperStatus;
    value: string;
};
declare class CindorStepper extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        interactive: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        orientation: {
            reflect: boolean;
        };
        steps: {
            attribute: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    interactive: boolean;
    orientation: StepperOrientation;
    steps: StepperStep[];
    value: string;
    connectedCallback(): void;
    focus(options?: FocusOptions): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<PropertyKey, unknown>): void;
    private renderBody;
    private renderIndicator;
    private getStepStatus;
    private normalizeValue;
    private selectStep;
    private get currentControl();
    private get hostAriaLabel();
    private get hostAriaDescribedBy();
    private get hostAriaLabelledBy();
}

declare class CindorSwitch extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        checked: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    checked: boolean;
    disabled: boolean;
    name: string;
    required: boolean;
    value: string;
    private defaultChecked;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private syncFormState;
    private get inputElement();
}

/**
 * Freeform tag entry with removable tokens.
 *
 * @fires {CustomEvent<TagInputChangeDetail>} input - Fired when the committed tag values change.
 * @fires {CustomEvent<TagInputChangeDetail>} change - Fired when the committed tag values change.
 */
declare class CindorTagInput extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        values: {
            attribute: boolean;
        };
    };
    disabled: boolean;
    name: string;
    placeholder: string;
    required: boolean;
    values: string[];
    private defaultValues;
    private draftValue;
    private initializedValues;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<string, unknown>): void;
    private handleBlur;
    private handleControlPointerDown;
    private handleInput;
    private handleKeyDown;
    private commitDraft;
    private removeTag;
    private dispatchValueEvents;
    private syncFormState;
    private syncValidity;
    private normalizeTag;
    private normalizeValues;
    private get inputElement();
    private get isValueMissing();
}

type TagTone = "neutral" | "accent" | "success";
/**
 * Compact tag surface for labels, filters, and removable metadata.
 *
 * @fires {Event} remove - Fired when the dismiss button is activated.
 * @slot - Tag label.
 */
declare class CindorTag extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        dismissible: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        removeLabel: {
            attribute: string;
            reflect: boolean;
        };
        tone: {
            reflect: boolean;
        };
    };
    dismissible: boolean;
    removeLabel: string;
    tone: TagTone;
    protected render(): lit_html.TemplateResult<1>;
    private handleRemoveClick;
}

/**
 * Optional tab panel wrapper for {@link CindorTabs}.
 *
 * @slot - Panel content.
 */
declare class CindorTabPanel extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        label: {
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    label: string;
    value: string;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    connectedCallback(): void;
    private syncPanelData;
}

declare class CindorTabs extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        value: {
            reflect: boolean;
        };
    };
    value: string;
    private readonly panelObserver;
    private panels;
    private panelIndex;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleSlotChange;
    private refreshPanels;
    private select;
    private focusTabAt;
    private handleTabKeydown;
    private syncPanels;
    private syncListA11y;
    private get tabElements();
    private get tabListElement();
}

declare class CindorTelInput extends BaseInputElement {
    autocomplete: string;
    protected get inputType(): string;
}

declare class CindorTextarea extends FormAssociatedElement {
    static styles: lit.CSSResultGroup[];
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        placeholder: {
            reflect: boolean;
        };
        readonly: {
            type: BooleanConstructor;
            reflect: boolean;
            attribute: string;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        rows: {
            type: NumberConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    name: string;
    placeholder: string;
    readonly: boolean;
    required: boolean;
    rows: number;
    value: string;
    private defaultValue;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleChange;
    private handleInput;
    private syncFormState;
    private get textareaElement();
}

/**
 * Ordered event timeline for status history and activity summaries.
 *
 * @slot - `cindor-timeline-item` children.
 */
declare class CindorTimeline extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Single event row used inside {@link CindorTimeline}.
 *
 * @slot title - Main event title.
 * @slot timestamp - Secondary event time or date.
 * @slot - Event body content.
 */
declare class CindorTimelineItem extends LitElement {
    static styles: lit.CSSResult;
    protected render(): lit_html.TemplateResult<1>;
}

/**
 * Hierarchical item used inside {@link CindorTreeView}.
 *
 * Set `label` for the visible row text and nest additional `cindor-tree-item`
 * elements in the default slot to create branches.
 *
 * @fires toggle - Fired when the expanded branch state changes.
 * @fires tree-item-select - Fired when the row is activated.
 *
 * @slot start - Optional leading decoration for the tree row.
 * @slot - Nested child `cindor-tree-item` elements for branch content.
 */
declare class CindorTreeItem extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        expanded: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        label: {
            reflect: boolean;
        };
        selected: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        value: {
            reflect: boolean;
        };
    };
    disabled: boolean;
    expanded: boolean;
    label: string;
    selected: boolean;
    value: string;
    private hasChildren;
    connectedCallback(): void;
    click(): void;
    focus(options?: FocusOptions): void;
    toggle(expanded?: boolean): void;
    protected updated(): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleItemClick;
    private handleSlotChange;
    private handleToggleClick;
    private syncButtonState;
    private syncChildren;
    private dispatchToggleEvent;
    private get nestedTreeItems();
    private get buttonElement();
}

/**
 * Keyboard-accessible single-selection tree view.
 *
 * Use nested `cindor-tree-item` elements to create branches and leaves.
 *
 * @fires input - Fired when the selected item changes.
 * @fires change - Fired when the selected item changes.
 *
 * @slot - Direct child `cindor-tree-item` elements.
 */
declare class CindorTreeView extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        value: {
            reflect: boolean;
        };
    };
    value: string;
    private readonly treeObserver;
    connectedCallback(): void;
    disconnectedCallback(): void;
    protected firstUpdated(): void;
    protected updated(changedProperties: Map<string, unknown>): void;
    protected render(): lit_html.TemplateResult<1>;
    private handleSlotChange;
    private handleTreeItemSelect;
    private handleTreeItemToggle;
    private handleKeyDown;
    private handleExpandKey;
    private handleCollapseKey;
    private refreshTree;
    private selectAndFocus;
    private selectItem;
    private parentItem;
    private levelFor;
    private collectVisibleItems;
    private get allItems();
    private get visibleItems();
    private ensureValidValue;
    private childItems;
    private itemButton;
    private itemValue;
}

declare class CindorTimeInput extends BaseInputElement {
    protected get inputType(): string;
}

type ToastTone = "neutral" | "success" | "warning" | "danger";
declare class CindorToast extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        dismissible: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        tone: {
            reflect: boolean;
        };
    };
    dismissible: boolean;
    open: boolean;
    tone: ToastTone;
    close: () => void;
    protected render(): lit_html.TemplateResult<1> | typeof nothing;
}

type ToastContent = Node | string;
type ToastPlacement = "top-start" | "top-end" | "bottom-start" | "bottom-end";
type ShowToastOptions = {
    content: ToastContent;
    dismissible?: boolean;
    duration?: number;
    id?: string;
    tone?: ToastTone;
};
declare function clearToasts(region?: CindorToastRegion): void;
declare function dismissToast(id: string, region?: CindorToastRegion): boolean;
declare function ensureToastRegion(root?: Document): CindorToastRegion;
declare function showToast(options: ShowToastOptions, region?: CindorToastRegion): string;

declare class CindorToastRegion extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        maxVisible: {
            type: NumberConstructor;
            reflect: boolean;
            attribute: string;
        };
        placement: {
            reflect: boolean;
        };
    };
    private static nextId;
    maxVisible: number;
    placement: ToastPlacement;
    private managedToasts;
    clear(): void;
    dismissToast(id: string): boolean;
    showToast(options: ShowToastOptions): string;
    protected render(): lit_html.TemplateResult<1>;
    disconnectedCallback(): void;
    private assignToastContent;
    private pruneOverflow;
    private removeToastById;
}

/**
 * Dual-list selector for moving items between available and selected collections.
 *
 * Use light-DOM `option` or `cindor-option` children as the source option set.
 *
 * @fires {CustomEvent<TransferListChangeDetail>} input - Fired when the selected values change.
 * @fires {CustomEvent<TransferListChangeDetail>} change - Fired when the selected values change.
 *
 * @slot - `option` or `cindor-option` children that define the available choices.
 */
declare class CindorTransferList extends FormAssociatedElement {
    static styles: lit.CSSResult;
    static properties: {
        availableLabel: {
            reflect: boolean;
            attribute: string;
        };
        disabled: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        name: {
            reflect: boolean;
        };
        required: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        selectedLabel: {
            reflect: boolean;
            attribute: string;
        };
        selectedValues: {
            attribute: boolean;
        };
        size: {
            type: NumberConstructor;
            reflect: boolean;
        };
    };
    availableLabel: string;
    disabled: boolean;
    name: string;
    required: boolean;
    selectedLabel: string;
    selectedValues: string[];
    size: number;
    private activeAvailableValues;
    private activeSelectedValues;
    private defaultSelectedValues;
    private initializedValues;
    private optionNodes;
    connectedCallback(): void;
    checkValidity(): boolean;
    focus(options?: FocusOptions): void;
    reportValidity(): boolean;
    formDisabledCallback(disabled: boolean): void;
    formResetCallback(): void;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(changedProperties: Map<string, unknown>): void;
    private handleSlotChange;
    private handleAvailableInput;
    private handleSelectedInput;
    private handleAvailableDoubleClick;
    private handleSelectedDoubleClick;
    private refreshOptions;
    private moveSelectedToChosen;
    private moveAllToChosen;
    private moveSelectedToAvailable;
    private moveAllToAvailable;
    private dispatchValueEvents;
    private syncFormState;
    private syncValidity;
    private syncLightDomSelection;
    private normalizedSelectedValues;
    private get availableOptions();
    private get availableMovableCount();
    private get selectedOptions();
    private get availableSelect();
    private get isValueMissing();
    private get selectedSelect();
}

declare class CindorTooltip extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        open: {
            type: BooleanConstructor;
            reflect: boolean;
        };
        text: {
            reflect: boolean;
        };
    };
    open: boolean;
    text: string;
    private static nextId;
    private floatingBubble;
    private floatingCleanup?;
    private tooltipId;
    private triggerNode;
    private updateFloatingPosition?;
    protected render(): lit_html.TemplateResult<1>;
    connectedCallback(): void;
    protected firstUpdated(): void;
    protected updated(): void;
    disconnectedCallback(): void;
    private show;
    private hide;
    private handleSlotChange;
    private handleTriggerKeyDown;
    private syncFloatingPosition;
    private destroyFloatingPosition;
    private get bubbleElement();
    private get triggerElement();
    private detachTriggerListeners;
    private syncTriggerDescription;
    private syncTriggerNode;
}

type ToolbarOrientation = "horizontal" | "vertical";
declare class CindorToolbar extends LitElement {
    static styles: lit.CSSResult;
    static properties: {
        orientation: {
            reflect: boolean;
        };
        wrap: {
            type: BooleanConstructor;
            reflect: boolean;
        };
    };
    orientation: ToolbarOrientation;
    wrap: boolean;
    protected render(): lit_html.TemplateResult<1>;
    protected updated(): void;
    private handleKeyDown;
    private handleSlotChange;
    private focusItem;
    private syncToolbarA11y;
    private collectToolbarItems;
    private isDisabled;
    private get toolbarElement();
    private get toolbarItems();
}

declare class CindorUrlInput extends BaseInputElement {
    autocomplete: string;
    protected get inputType(): string;
}

export { type AlertTone, type AutocompleteSuggestion, type BadgeTone, type ButtonGroupOrientation, type ButtonType, type ButtonVariant, type ChipTone, CindorAccordion, CindorActivityFeed, CindorActivityItem, CindorAlert, CindorAutocomplete, CindorAvatar, CindorBadge, CindorBreadcrumbs, CindorButton, CindorButtonGroup, CindorCalendar, CindorCard, CindorCheckbox, CindorChip, CindorCodeBlock, CindorColorInput, CindorCombobox, CindorCommandBar, CindorCommandPalette, CindorContextMenu, CindorDataTable, CindorDateInput, CindorDatePicker, CindorDateRangePicker, CindorDateTimePicker, CindorDescriptionItem, CindorDescriptionList, CindorDialog, CindorDivider, CindorDrawer, CindorDropdownMenu, CindorDropzone, CindorEmailInput, CindorEmptySearchResults, CindorEmptyState, CindorErrorText, CindorFieldset, CindorFileInput, CindorFilterBuilder, CindorForm, CindorFormField, CindorFormRow, CindorHelperText, CindorIcon, CindorIconButton, CindorInlineEdit, CindorInput, CindorLayout, CindorLayoutContent, CindorLayoutHeader, CindorLink, CindorListbox, CindorMenu, CindorMenuItem, CindorMenubar, CindorMeter, CindorMultiSelect, CindorNavigationRail, CindorNavigationRailItem, CindorNumberInput, CindorOption, CindorPageHeader, CindorPagination, CindorPanelInspector, CindorPasswordInput, CindorPopover, CindorProgress, CindorProvider, CindorRadio, CindorRange, CindorRatingInput, CindorSearch, CindorSegmentedControl, CindorSelect, CindorSideNav, CindorSideNavItem, CindorSkeleton, CindorSpinner, CindorSplitter, CindorSplitterPanel, CindorStack, CindorStatCard, CindorStepper, CindorSwitch, CindorTabPanel, CindorTabs, CindorTag, CindorTagInput, CindorTelInput, CindorTextarea, CindorTimeInput, CindorTimeline, CindorTimelineItem, CindorToast, CindorToastRegion, CindorToolbar, CindorTooltip, CindorTransferList, CindorTreeItem, CindorTreeView, CindorUrlInput, type CommandPaletteCommand, type DataTableColumn, type DataTableRow, type DataTableSortDirection, type DrawerSide, type FilterBuilderField, type FilterBuilderFieldType, type FilterBuilderGroup, type FilterBuilderLogic, type FilterBuilderNode, type FilterBuilderOperator, type FilterBuilderOption, type FilterBuilderRule, type LucideIconName, type ProviderColorScheme, type ProviderTheme, type SegmentedControlOption, type ShowToastOptions, type SkeletonVariant, type SplitterOrientation, type StackAlign, type StackDirection, type StackGap, type StackJustify, type StatCardTone, type StepperOrientation, type StepperStatus, type StepperStep, type TagTone, type ToastPlacement, type ToastTone, type ToolbarOrientation, clearToasts, dismissToast, ensureToastRegion, showToast };
