@timlassiter11/yatl-ui 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,768 @@
+import * as lit_html from 'lit-html';
+import * as lit from 'lit';
+import { LitElement, PropertyValues, nothing, ComplexAttributeConverter, ReactiveController, ReactiveControllerHost } from 'lit';
+export { html, noChange, nothing, svg } from 'lit';
+import * as _timlassiter11_yatl from '@timlassiter11/yatl';
+import { UnspecifiedRecord, YatlTable, YatlTableController, DisplayColumnOptions } from '@timlassiter11/yatl';
+export { unsafeHTML } from 'lit/directives/unsafe-html.js';
+
+declare class YatlBase extends LitElement {
+    static styles: lit.CSSResult[];
+}
+
+type YatlButtonVariant = 'neutral' | 'outline' | 'plain';
+type YatlButtonColor = 'neutral' | 'brand' | 'danger' | 'warning' | 'success' | 'raised' | 'muted';
+declare class YatlButton extends YatlBase {
+    static styles: lit.CSSResult[];
+    disabled: boolean;
+    type: 'button' | 'submit' | 'reset';
+    variant: YatlButtonVariant;
+    color: YatlButtonColor;
+    protected render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-button': YatlButton;
+    }
+}
+
+declare class YatlButtonGroup extends YatlBase {
+    static styles: lit.CSSResult[];
+    protected render(): lit_html.TemplateResult<1>;
+    private handleSlotChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-button-group': YatlButtonGroup;
+    }
+}
+
+declare class YatlCard extends YatlBase {
+    static styles: lit.CSSResult[];
+    private slotController;
+    protected render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-card': YatlCard;
+    }
+}
+
+declare class YatlConfirmationDialog extends YatlBase {
+    static styles: lit.CSSResult[];
+    private dialogElement?;
+    open: boolean;
+    modal: boolean;
+    label: string;
+    acceptText: string;
+    rejectText: string;
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    confirm(): Promise<boolean>;
+    accept(): Promise<void>;
+    reject(): Promise<void>;
+    protected render(): lit_html.TemplateResult<1>;
+    private handleDialogShow;
+    private handleDialogHide;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-confirmation-dialog': YatlConfirmationDialog;
+    }
+}
+
+declare class YatlDialog extends YatlBase {
+    static styles: lit.CSSResult[];
+    private _open;
+    private _transitionPromise?;
+    get transitionComplete(): Promise<void> | undefined;
+    private set transitionComplete(value);
+    get isTransitioning(): boolean;
+    private dialogElement?;
+    label: string;
+    modal: boolean;
+    get open(): boolean;
+    set open(value: boolean);
+    show(): Promise<void>;
+    hide(): Promise<void>;
+    protected firstUpdated(_changedProperties: PropertyValues): void;
+    protected render(): lit_html.TemplateResult<1>;
+    private requestClose;
+    private handleCloseClick;
+    private handleDialogPointerdown;
+    private handleDialogCancel;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-dialog': YatlDialog;
+    }
+}
+
+/**
+ * @fires yatl-dropdown-select
+ * @fires yatl-dropdown-open
+ * @fires yatl-dropdown-close
+ */
+declare class YatlDropdown extends YatlBase {
+    static styles: lit.CSSResult[];
+    private autoUpdateCleanup?;
+    private menuElement;
+    private triggerSlot?;
+    private defaultSlot?;
+    open: boolean;
+    matchWidth: boolean;
+    protected render(): lit_html.TemplateResult<1>;
+    protected updated(changedProperties: PropertyValues<YatlDropdown>): void;
+    disconnectedCallback(): void;
+    private handleTriggerClick;
+    private handleItemClick;
+    private handleTriggerKeydown;
+    private handleKeydown;
+    private handleDocumentFocusin;
+    private addListeners;
+    private removeListeners;
+    private getItems;
+    private getActiveItem;
+    private startPositioning;
+    private get referenceElement();
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-dropdown': YatlDropdown;
+    }
+}
+
+declare class YatlIcon extends YatlBase {
+    static styles: lit.CSSResult[];
+    name: string;
+    viewBox: string;
+    label: string;
+    render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-icon': YatlIcon;
+    }
+}
+
+declare class YatlOption extends YatlBase {
+    static styles: lit.CSSResult[];
+    value: string;
+    checkable: boolean;
+    checked: boolean;
+    disabled: boolean;
+    label: string;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderLabel(): lit_html.TemplateResult<1>;
+    protected renderCheck(): lit_html.TemplateResult<1> | typeof nothing;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    private handleItemClicked;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-option': YatlOption;
+    }
+}
+
+/**
+ * A "Batteries Included" wrapper for `<yatl-table>` that provides a built-in toolbar.
+ *
+ * This element extends the core table engine to automatically render UI controls
+ * for common user actions, such as toggling column visibility and exporting data.
+ *
+ * It inherits all properties and events from `<yatl-table>`.
+ *
+ * @element yatl-table-ui
+ *
+ * @slot toolbar - Adds contents to the right of the toolbar button group
+ * @slot toolbar-button-group - Adds content into the toolbar button group.
+ * @slot footer - Inherited from `yatl-table`. Content to display in the table footer area.
+ * @slot body - Inherited from `yatl-table`. Custom rendering for the table body.
+ */
+declare class YatlTableUi<T extends object = UnspecifiedRecord> extends YatlTable<T> {
+    static styles: lit.CSSResult[];
+    /**
+     * Toggles the visibility of the column picker button in the toolbar. Defaults to `true`.
+     */
+    showColumnPicker: boolean;
+    /**
+     * Toggles the visibility of the CSV export button in the toolbar. Defaults to `true`.
+     */
+    showExportButton: boolean;
+    protected render(): lit_html.TemplateResult<1>;
+    private handleTableExportClicked;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-table-ui': YatlTableUi;
+    }
+}
+
+declare class YatlTableView extends YatlTableUi {
+    static styles: lit.CSSResult[];
+    private tableContext;
+    protected willUpdate(changedProperties: PropertyValues<YatlTableView>): void;
+    protected render(): lit_html.TemplateResult<1>;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-table-view': YatlTableView;
+    }
+}
+
+/**
+ * @fires yatl-tag-dismiss-request
+ * @fires yatl-tag-dismiss
+ */
+declare class YatlTag extends YatlBase {
+    static styles: lit.CSSResult[];
+    dismissable: boolean;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderClearIcon(): lit_html.TemplateResult<1> | typeof nothing;
+    private dismissClick;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-tag': YatlTag;
+    }
+}
+
+/**
+ * A table toolbar component with a search input, column picker, and export button.
+ *
+ * @element yatl-toolbar
+ * @summary Provides a cohesive set of controls for searching, exporting, and managing column visibility,
+ * along with a flexible slot for custom actions.
+ *
+ * @slot - Adds contents to the right of the toolbar button group
+ * @slot toolbar-button-group - Adds content into the toolbar button group.
+ * @slot column-picker-trigger - Replaces the button used to trigger the column picker.
+ * @slot column-picker-icon - Replaces the icon for the column picker button.
+ * @slot export-button-icon - Replaces the icon for the export button.
+ *
+ * @fires yatl-toolbar-search-input - Fired synchronously as the user types in the search box. Useful for real-time highlighting or suggestions.
+ * @fires yatl-toolbar-search-change - Fired when the user commits a search query (e.g., on 'Enter' or blur). Use this for triggering the actual table filter.
+ * @fires yatl-toolbar-export-click - Fired when the export button is clicked. Payload indicates the requested format.
+ * @fires yatl-column-toggle-request - Fired when a column's visibility is toggled in the dropdown. The consumer must handle this by updating the table state.
+ *
+ */
+declare class YatlToolbar<T extends object = UnspecifiedRecord> extends YatlBase {
+    static styles: lit.CSSResult[];
+    private _controller?;
+    get controller(): YatlTableController<T> | undefined;
+    set controller(controller: YatlTableController<T> | undefined);
+    showColumnPicker: boolean;
+    showExportButton: boolean;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderColumnPicker(): lit_html.TemplateResult<1>;
+    protected renderColumnVisibilityToggle(column: DisplayColumnOptions<T>): lit_html.TemplateResult<1>;
+    private handleDropdownSelect;
+    protected renderExportButton(): lit_html.TemplateResult<1>;
+    private onSearchInput;
+    private onSearchChange;
+    private onExportClick;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-toolbar': YatlToolbar;
+    }
+}
+
+declare class YatlBaseFilter<T> extends YatlBase {
+    private _filterOptions?;
+    private _controller?;
+    get controller(): YatlTableController<_timlassiter11_yatl.UnspecifiedRecord> | undefined;
+    set controller(controller: YatlTableController<_timlassiter11_yatl.UnspecifiedRecord> | undefined);
+    private _value?;
+    get value(): T | undefined;
+    set value(value: T | undefined);
+    field: string;
+    label: string;
+    protected get filters(): Partial<{
+        [x: string]: unknown;
+    }> | null | undefined;
+    protected set filters(filters: Partial<{
+        [x: string]: unknown;
+    }> | null | undefined);
+    protected get options(): Map<T, number>;
+    protected willUpdate(changedProperties: PropertyValues): void;
+    protected updateFilters(): void;
+    private updateFilterOptions;
+}
+
+declare class YatlDateFilter extends YatlBaseFilter<Date> {
+    static styles: lit.CSSResult[];
+    protected render(): lit_html.TemplateResult<1>;
+    private handleChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-date-filter': YatlDateFilter;
+    }
+}
+
+declare class YatlSearchFilter extends YatlBaseFilter<string[]> {
+    static styles: lit.CSSResult[];
+    size: number;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderSelectOptions(): unknown;
+    protected renderDropdownOption(value: string, count: number): lit_html.TemplateResult<1>;
+    private handleSelectChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-search-filter': YatlSearchFilter;
+    }
+}
+
+declare class YatlSelectFilter extends YatlBaseFilter<string[]> {
+    static styles: lit.CSSResult[];
+    placeholder: string;
+    maxTags: number;
+    multi: boolean;
+    clearable: boolean;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderSelectOptions(): unknown;
+    protected renderDropdownOption(value: string, count: number): lit_html.TemplateResult<1>;
+    private handleSelectChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-select-filter': YatlSelectFilter;
+    }
+}
+
+type FormControl = HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement | YatlFormControl;
+declare abstract class YatlFormControl<TData = string, TInput extends FormControl = HTMLInputElement> extends YatlBase implements ElementInternals {
+    static formAssociated: boolean;
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    static styles: lit.CSSResult[];
+    protected readonly internals: ElementInternals;
+    private slotController;
+    /**
+     * Used to associate the label with the control element
+     */
+    readonly inputId = "input";
+    protected formControl?: TInput;
+    protected labelSlot?: HTMLSlotElement;
+    name: string;
+    label: string;
+    hint: string;
+    disabled: boolean;
+    readonly: boolean;
+    required: boolean;
+    inline: boolean;
+    abstract value?: TData;
+    abstract defaultValue?: TData;
+    abstract formValue: string | File | FormData | null;
+    protected onValueChange(_event: Event): boolean | void;
+    private _errorText;
+    get errorText(): string;
+    requiredText: string;
+    set errorText(newValue: string);
+    protected get hasLabel(): boolean;
+    protected get hasHint(): boolean;
+    protected get hasError(): boolean;
+    constructor();
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    connectedCallback(): void;
+    protected willUpdate(changedProperties: PropertyValues<YatlFormControl<TData, TInput>>): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderBase(contents: unknown): lit_html.TemplateResult<1>;
+    protected renderLabel(): unknown;
+    protected renderHint(): unknown;
+    protected renderErrorText(): unknown;
+    protected abstract renderInput(): unknown;
+    protected get hasErrorText(): boolean;
+    get labels(): NodeList;
+    get states(): CustomStateSet;
+    get validity(): ValidityState;
+    get validationMessage(): string;
+    get willValidate(): boolean;
+    get form(): HTMLFormElement | null;
+    setFormValue(value: string | File | FormData | null): void;
+    setValidity(flags?: ValidityStateFlags, message?: string, anchor?: HTMLElement): void;
+    checkValidity(): boolean;
+    reportValidity(): boolean;
+    formResetCallback(): void;
+    private updateValidity;
+    protected toggleState(name: string, state?: boolean): void;
+    private handleInputChange;
+}
+
+declare class YatlCheckbox extends YatlFormControl<string> {
+    static styles: lit.CSSResult[];
+    private _value;
+    private _uncheckedValue?;
+    /**
+     * The value to store in the form data if the checkbox is checked
+     */
+    get value(): string;
+    set value(value: string);
+    get defaultValue(): string;
+    get uncheckedValue(): string | undefined;
+    set uncheckedValue(value: string | undefined);
+    defaultChecked: boolean;
+    alwaysInclude: boolean;
+    inline: boolean;
+    private _checked;
+    get checked(): boolean;
+    set checked(value: boolean);
+    get formValue(): string | null;
+    formResetCallback(): void;
+    constructor();
+    connectedCallback(): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    private updateFormValue;
+    protected onValueChange(event: Event): void;
+    private handleClick;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-checkbox': YatlCheckbox;
+    }
+}
+
+declare class YatlDateInput extends YatlFormControl<Date> {
+    static styles: lit.CSSResult[];
+    placeholder: string;
+    size: number;
+    min?: Date;
+    max?: Date;
+    defaultValue?: Date;
+    private _value?;
+    get value(): Date | undefined;
+    set value(value: Date | undefined);
+    get formValue(): string | null;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    protected onValueChange(event: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-date-input': YatlDateInput;
+    }
+}
+
+type YatlInputType = 'email' | 'password' | 'search' | 'text' | 'tel' | 'url';
+declare class YatlInput extends YatlFormControl<string> {
+    static styles: lit.CSSResult[];
+    type: YatlInputType;
+    size: number;
+    /** A regular expression pattern to validate input against. */
+    pattern?: string;
+    /** The input's minimum value. Only applies to date and number input types. */
+    placeholder: string;
+    passwordToggle: boolean;
+    /** The minimum length of input that will be considered valid. */
+    minlength?: number;
+    /** The maximum length of input that will be considered valid. */
+    maxlength?: number;
+    showCount: boolean;
+    defaultValue: string;
+    value: string;
+    get formValue(): string;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    protected renderLabel(): lit_html.TemplateResult<1> | typeof nothing;
+    protected renderCount(): lit_html.TemplateResult<1>;
+    protected onValueChange(event: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-input': YatlInput;
+    }
+}
+
+declare class YatlNumberInput extends YatlFormControl<number> {
+    static styles: lit.CSSResult[];
+    placeholder: string;
+    size: number;
+    min?: number;
+    max?: number;
+    defaultValue?: number;
+    value?: number;
+    get formValue(): string;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    protected onValueChange(event: Event): void;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-number-input': YatlNumberInput;
+    }
+}
+
+declare class YatlRadio extends YatlFormControl<string> {
+    static styles: lit.CSSResult[];
+    private _value;
+    private _uncheckedValue?;
+    /**
+     * The value to store in the form data if the checkbox is checked
+     */
+    get value(): string;
+    set value(value: string);
+    get defaultValue(): string;
+    get uncheckedValue(): string | undefined;
+    set uncheckedValue(value: string | undefined);
+    defaultChecked: boolean;
+    alwaysInclude: boolean;
+    inline: boolean;
+    private _checked;
+    get checked(): boolean;
+    set checked(value: boolean);
+    get formValue(): string | null;
+    formResetCallback(): void;
+    constructor();
+    connectedCallback(): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    private updateFormValue;
+    protected onValueChange(event: Event): void;
+    private handleClick;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-radio': YatlRadio;
+    }
+}
+
+declare class YatlRadioGroup extends YatlFormControl<string> {
+    static styles: lit.CSSResult[];
+    defaultValue: string;
+    value: string;
+    get formValue(): string;
+    connectedCallback(): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    protected onValueChange(event: Event): boolean;
+    private syncChildStates;
+    private getAllChildren;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-radio-group': YatlRadioGroup;
+    }
+}
+
+declare class YatlSearchSelect extends YatlFormControl<string[]> {
+    static styles: lit.CSSResult[];
+    static shadowRootOptions: {
+        delegatesFocus: boolean;
+        clonable?: boolean;
+        customElementRegistry?: CustomElementRegistry;
+        mode: ShadowRootMode;
+        serializable?: boolean;
+        slotAssignment?: SlotAssignmentMode;
+    };
+    private noMatch;
+    private hasFocus;
+    placeholder: string;
+    noResultsText: string;
+    matchWidth: boolean;
+    size: number;
+    defaultValue: never[];
+    private _value;
+    get value(): string[];
+    set value(value: string[]);
+    get formValue(): FormData;
+    get hasSelection(): boolean;
+    constructor();
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    toggleOption(value: string, state?: boolean): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    protected renderContents(): unknown;
+    protected renderSelectedOptions(): unknown;
+    protected renderOption(option: YatlOption): lit_html.TemplateResult<1>;
+    private handleOptionClick;
+    private handleFocus;
+    private handleInput;
+    private handleSlotChange;
+    private handleSelectedOptionClick;
+    private updateVisibleOptions;
+    private updateSelectedOptions;
+    private getSelectedOptions;
+    private getAllOptions;
+    private dispatchChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-search-select': YatlSearchSelect;
+    }
+}
+
+declare class YatlSelect extends YatlFormControl<string[], YatlFormControl> {
+    static styles: lit.CSSResult[];
+    placeholder: string;
+    multi: boolean;
+    maxTags: number;
+    defaultValue: never[];
+    open: boolean;
+    clearable: boolean;
+    private _value;
+    get value(): string[];
+    set value(value: string[]);
+    get formValue(): FormData;
+    toggleOption(value: string, state?: boolean): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    protected renderDisplayValue(): lit_html.TemplateResult<1> | typeof nothing;
+    protected renderTags(): lit_html.TemplateResult<1> | typeof nothing;
+    protected renderTag(option: YatlOption): lit_html.TemplateResult<1>;
+    protected renderClearIcon(): lit_html.TemplateResult<1> | typeof nothing;
+    protected renderArrowIcon(): lit_html.TemplateResult<1>;
+    private handleTagDissmiss;
+    private handleSlotChange;
+    private handleClearButtonClick;
+    private handleDropdownToggle;
+    private handleDropdownSelect;
+    private updateSelectedOptions;
+    private getSelectedOptions;
+    private getAllOptions;
+    private dispatchChange;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-select': YatlSelect;
+    }
+}
+
+declare class YatlSwitch extends YatlFormControl<string> {
+    static styles: lit.CSSResult[];
+    private _value;
+    private _uncheckedValue?;
+    /**
+     * The value to store in the form data if the checkbox is checked
+     */
+    get value(): string;
+    set value(value: string);
+    get defaultValue(): string;
+    get uncheckedValue(): string | undefined;
+    set uncheckedValue(value: string | undefined);
+    defaultChecked: boolean;
+    alwaysInclude: boolean;
+    inline: boolean;
+    private _checked;
+    get checked(): boolean;
+    set checked(value: boolean);
+    get formValue(): string | null;
+    formResetCallback(): void;
+    constructor();
+    connectedCallback(): void;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): lit_html.TemplateResult<1>;
+    private updateFormValue;
+    protected onValueChange(event: Event): void;
+    private handleClick;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-switch': YatlSwitch;
+    }
+}
+
+declare class YatlTypeahead extends YatlFormControl {
+    static styles: lit.CSSResult[];
+    private _uri;
+    private _minQueryLength;
+    private _searchParam;
+    private _debounceTimer;
+    private loading;
+    private error;
+    private options;
+    private open;
+    placeholder: string;
+    defaultValue: string;
+    value: string;
+    get formValue(): string;
+    get uri(): string;
+    set uri(uri: string);
+    get minQueryLength(): number;
+    set minQueryLength(value: number);
+    get searchParam(): string;
+    set searchParam(value: string);
+    searchDebounce: number;
+    parser?: (value: unknown) => string[];
+    protected get hasOptions(): boolean;
+    protected get canSearch(): boolean;
+    protected render(): lit_html.TemplateResult<1>;
+    protected renderInput(): void;
+    protected renderDropdownContent(): unknown;
+    protected renderOption(option: string): lit_html.TemplateResult<1>;
+    protected onValueChange(event: Event): boolean | void;
+    private handleDropdownSelect;
+    private handleDropdownRequest;
+    private handleDropdownClose;
+    private scheduleFetch;
+    private updateOptions;
+}
+declare global {
+    interface HTMLElementTagNameMap {
+        'yatl-typeahead': YatlTypeahead;
+    }
+}
+
+/**
+ * Retrieves the flattened list of elements assigned to a slot.
+ *
+ * Unlike the native `assignedElements({flatten: true})`, this function
+ * correctly falls back to the slot's default content (its light DOM children)
+ * if no nodes are assigned.
+ *
+ * It recursively resolves nested slots in the default content to ensure
+ * you always get the final rendered leaf elements.
+ */
+declare function getEffectiveChildren(node: Node): Element[];
+/**
+ * Lit Property converter to convert between date string and date objects
+ */
+declare class DateConverter implements ComplexAttributeConverter<Date | undefined> {
+    fromAttribute(value: string): Date | undefined;
+    toAttribute(value: Date | string | undefined): string | null;
+}
+declare const dateConverter: DateConverter;
+/**
+ * Use a generator so we can iterate and possibly break early.
+ * @example
+ *   // to operate like a regular array. This kinda nullifies generator benefits, but worth knowing if you need the whole array.
+ *   const allActiveElements = [...activeElements()]
+ *
+ *   // Early return
+ *   for (const activeElement of activeElements()) {
+ *     if (<cond>) {
+ *       break; // Break the loop, don't need to iterate over the whole array or store an array in memory!
+ *     }
+ *   }
+ */
+declare function activeElements(activeElement?: Element | null): Generator<Element>;
+declare function animateWithClass(element: HTMLElement, className: string, timeout?: number): Promise<void>;
+
+/** A reactive controller that determines when slots exist. */
+declare class HasSlotController implements ReactiveController {
+    private host;
+    private slotNames;
+    constructor(host: ReactiveControllerHost & Element, ...slotNames: string[]);
+    private hasDefaultSlot;
+    private hasNamedSlot;
+    test(slotName: string): boolean;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private handleSlotChange;
+}
+/**
+ * Given a list of nodes, this function iterates over all of them and returns the concatenated
+ * HTML as a string. This is useful for getting the HTML that corresponds to a slot’s assigned nodes (since we can't use slot.innerHTML as an alternative).
+ * @param nodes - The list of nodes to iterate over.
+ * @param callback - A function that can be used to customize the HTML output for specific types of nodes. If the function returns undefined, the default HTML output will be used.
+ */
+declare function getInnerHTML(nodes: Iterable<Node>, callback?: (node: Node) => string | undefined): string;
+
+export { type FormControl, HasSlotController, YatlBaseFilter, YatlButton, type YatlButtonColor, YatlButtonGroup, type YatlButtonVariant, YatlCard, YatlCheckbox, YatlConfirmationDialog, YatlDateFilter, YatlDateInput, YatlDialog, YatlDropdown, YatlFormControl, YatlIcon, YatlInput, type YatlInputType, YatlNumberInput, YatlOption, YatlRadio, YatlRadioGroup, YatlSearchFilter, YatlSearchSelect, YatlSelect, YatlSelectFilter, YatlSwitch, YatlTableUi, YatlTableView, YatlTag, YatlToolbar, YatlTypeahead, activeElements, animateWithClass, dateConverter, getEffectiveChildren, getInnerHTML };