@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/overlay.d.ts

@@ -0,0 +1,67 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/overlay';
+import type { LuzmoOverlay as LuzmoOverlayHostElement } from '@luzmo/lucero/overlay';
+import * as i0 from "@angular/core";
+export declare class LuzmoOverlay implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoOverlayHostElement;
+    /** An Overlay that is `delayed` will wait until a warm-up period of 1000ms has completed before opening. Once the warm-up period has completed, all subsequent Overlays will open immediately. When no Overlays are opened, a cool-down period of 1000ms will begin. Once the cool-down has completed, the next Overlay to be opened will be subject to the warm-up period if provided that option.  This behavior helps to manage the performance and user experience by preventing multiple overlays from opening simultaneously and ensuring a smooth transition between opening and closing overlays. */
+    delayed?: boolean;
+    /** A reference to the dialog element within the overlay. This element is expected to have `showPopover` and `hidePopover` methods. */
+    dialogEl?: unknown;
+    /** Indicates whether the overlay is currently functional or not.  When set to `true`, the overlay is disabled, and any active strategy is aborted. The overlay will also close if it is currently open. When set to `false`, the overlay will re-bind events and re-open if it was previously open. */
+    disabled?: boolean;
+    /** A query to gather all elements slotted into the default slot, excluding elements with the slot name "longpress-describedby-descriptor". */
+    elements?: unknown;
+    /** A reference to the parent overlay that should be force-closed, if any. */
+    parentOverlayToForceClose?: unknown;
+    /** The `offset` property accepts either a single number to define the offset of the Overlay along the main axis from the trigger, or a 2-tuple to define the offset along both the main axis and the cross axis. This option has no effect when there is no trigger element. */
+    offset?: number | [number, number];
+    /** Indicates whether the Overlay is projected onto the "top layer" or not.  When set to `true`, the overlay is open and visible. When set to `false`, the overlay is closed and hidden. */
+    open?: boolean;
+    /** Instruct the Overlay where to place itself in relationship to the trigger element. */
+    placement?: "top" | "top-start" | "top-end" | "right" | "right-start" | "right-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end";
+    /** Whether to pass focus to the overlay once opened, or to the appropriate value based on the "type" of the overlay when set to `"auto"`. */
+    receivesFocus?: 'true' | 'false' | 'auto';
+    /** A reference to the slot element within the overlay.  This element is used to manage the content slotted into the overlay. */
+    slotEl?: unknown;
+    /** The current state of the overlay.  This property reflects the current state of the overlay, such as 'opened' or 'closed'. When the state changes, it triggers the appropriate actions and updates the component. */
+    state?: ('closed' | 'opening' | 'opened' | 'closing');
+    /** The interaction strategy for opening the overlay. This can be a ClickController, HoverController, or LongpressController. */
+    strategy?: unknown;
+    /** The padding around the tip of the overlay. This property defines the padding around the tip of the overlay, which can be used to adjust its positioning. */
+    tipPadding?: number;
+    /** An optional ID reference for the trigger element combined with the optional interaction (click | hover | longpress) by which the overlay should open. The format is `trigger@interaction`, e.g., `trigger@click` opens the overlay when an element with the ID "trigger" is clicked. */
+    trigger?: string;
+    /** An element reference for the trigger element that the overlay should relate to. This property is not reflected as an attribute. */
+    triggerElement?: unknown;
+    /** The specific interaction to listen for on the `triggerElement` to open the overlay. This property is not reflected as an attribute. */
+    triggerInteraction?: ('click' | 'longpress' | 'hover');
+    /** Configures the open/close heuristics of the Overlay. */
+    type?: "auto" | "hint" | "manual" | "modal" | "page";
+    /** announces that an overlay has completed any entry animations */
+    readonly luzmoOpenedEvent: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** announce that an overlay has compelted any exit animations */
+    readonly luzmoClosedEvent: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** requests to add or remove slottable content */
+    readonly slottableRequestEvent: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoOverlay, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoOverlay, "luzmo-overlay", ["luzmoOverlay"], { "delayed": { "alias": "delayed"; "required": false; }; "dialogEl": { "alias": "dialog-el"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "elements": { "alias": "elements"; "required": false; }; "parentOverlayToForceClose": { "alias": "parent-overlay-to-force-close"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "open": { "alias": "open"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "receivesFocus": { "alias": "receives-focus"; "required": false; }; "slotEl": { "alias": "slot-el"; "required": false; }; "state": { "alias": "state"; "required": false; }; "strategy": { "alias": "strategy"; "required": false; }; "tipPadding": { "alias": "tip-padding"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "triggerElement": { "alias": "trigger-element"; "required": false; }; "triggerInteraction": { "alias": "trigger-interaction"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, { "luzmoOpenedEvent": "luzmo-opened"; "luzmoClosedEvent": "luzmo-closed"; "slottableRequestEvent": "slottable-request"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoOverlay */
+export type LuzmoOverlayElement = LuzmoOverlayHostElement;

package/esm/components/overlay.js

@@ -0,0 +1,212 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/overlay';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-overlay>
+ */
+export class LuzmoOverlay {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    /** An Overlay that is `delayed` will wait until a warm-up period of 1000ms has completed before opening. Once the warm-up period has completed, all subsequent Overlays will open immediately. When no Overlays are opened, a cool-down period of 1000ms will begin. Once the cool-down has completed, the next Overlay to be opened will be subject to the warm-up period if provided that option.  This behavior helps to manage the performance and user experience by preventing multiple overlays from opening simultaneously and ensuring a smooth transition between opening and closing overlays. */
+    delayed;
+    /** A reference to the dialog element within the overlay. This element is expected to have `showPopover` and `hidePopover` methods. */
+    dialogEl;
+    /** Indicates whether the overlay is currently functional or not.  When set to `true`, the overlay is disabled, and any active strategy is aborted. The overlay will also close if it is currently open. When set to `false`, the overlay will re-bind events and re-open if it was previously open. */
+    disabled;
+    /** A query to gather all elements slotted into the default slot, excluding elements with the slot name "longpress-describedby-descriptor". */
+    elements;
+    /** A reference to the parent overlay that should be force-closed, if any. */
+    parentOverlayToForceClose;
+    /** The `offset` property accepts either a single number to define the offset of the Overlay along the main axis from the trigger, or a 2-tuple to define the offset along both the main axis and the cross axis. This option has no effect when there is no trigger element. */
+    offset;
+    /** Indicates whether the Overlay is projected onto the "top layer" or not.  When set to `true`, the overlay is open and visible. When set to `false`, the overlay is closed and hidden. */
+    open;
+    /** Instruct the Overlay where to place itself in relationship to the trigger element. */
+    placement;
+    /** Whether to pass focus to the overlay once opened, or to the appropriate value based on the "type" of the overlay when set to `"auto"`. */
+    receivesFocus;
+    /** A reference to the slot element within the overlay.  This element is used to manage the content slotted into the overlay. */
+    slotEl;
+    /** The current state of the overlay.  This property reflects the current state of the overlay, such as 'opened' or 'closed'. When the state changes, it triggers the appropriate actions and updates the component. */
+    state;
+    /** The interaction strategy for opening the overlay. This can be a ClickController, HoverController, or LongpressController. */
+    strategy;
+    /** The padding around the tip of the overlay. This property defines the padding around the tip of the overlay, which can be used to adjust its positioning. */
+    tipPadding;
+    /** An optional ID reference for the trigger element combined with the optional interaction (click | hover | longpress) by which the overlay should open. The format is `trigger@interaction`, e.g., `trigger@click` opens the overlay when an element with the ID "trigger" is clicked. */
+    trigger;
+    /** An element reference for the trigger element that the overlay should relate to. This property is not reflected as an attribute. */
+    triggerElement;
+    /** The specific interaction to listen for on the `triggerElement` to open the overlay. This property is not reflected as an attribute. */
+    triggerInteraction;
+    /** Configures the open/close heuristics of the Overlay. */
+    type;
+    /** announces that an overlay has completed any entry animations */
+    luzmoOpenedEvent = output({ alias: 'luzmo-opened' });
+    /** announce that an overlay has compelted any exit animations */
+    luzmoClosedEvent = output({ alias: 'luzmo-closed' });
+    /** requests to add or remove slottable content */
+    slottableRequestEvent = output({ alias: 'slottable-request' });
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'delayed':
+                    this.setHostProperty('delayed', changes['delayed'].currentValue);
+                    break;
+                case 'dialogEl':
+                    this.setHostProperty('dialogEl', changes['dialogEl'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'elements':
+                    this.setHostProperty('elements', changes['elements'].currentValue);
+                    break;
+                case 'parentOverlayToForceClose':
+                    this.setHostProperty('parentOverlayToForceClose', changes['parentOverlayToForceClose'].currentValue);
+                    break;
+                case 'offset':
+                    this.setHostProperty('offset', changes['offset'].currentValue);
+                    break;
+                case 'open':
+                    this.setHostProperty('open', changes['open'].currentValue);
+                    break;
+                case 'placement':
+                    this.setHostProperty('placement', changes['placement'].currentValue);
+                    break;
+                case 'receivesFocus':
+                    this.setHostProperty('receivesFocus', changes['receivesFocus'].currentValue);
+                    break;
+                case 'slotEl':
+                    this.setHostProperty('slotEl', changes['slotEl'].currentValue);
+                    break;
+                case 'state':
+                    this.setHostProperty('state', changes['state'].currentValue);
+                    break;
+                case 'strategy':
+                    this.setHostProperty('strategy', changes['strategy'].currentValue);
+                    break;
+                case 'tipPadding':
+                    this.setHostProperty('tipPadding', changes['tipPadding'].currentValue);
+                    break;
+                case 'trigger':
+                    this.setHostProperty('trigger', changes['trigger'].currentValue);
+                    break;
+                case 'triggerElement':
+                    this.setHostProperty('triggerElement', changes['triggerElement'].currentValue);
+                    break;
+                case 'triggerInteraction':
+                    this.setHostProperty('triggerInteraction', changes['triggerInteraction'].currentValue);
+                    break;
+                case 'type':
+                    this.setHostProperty('type', changes['type'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-opened', (event) => {
+            this.luzmoOpenedEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'luzmo-closed', (event) => {
+            this.luzmoClosedEvent.emit(event);
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'slottable-request', (event) => {
+            this.slottableRequestEvent.emit(event);
+        }));
+    }
+    static ɵfac = function LuzmoOverlay_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoOverlay)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoOverlay, selectors: [["luzmo-overlay"]], inputs: { delayed: "delayed", dialogEl: [0, "dialog-el", "dialogEl"], disabled: "disabled", elements: "elements", parentOverlayToForceClose: [0, "parent-overlay-to-force-close", "parentOverlayToForceClose"], offset: "offset", open: "open", placement: "placement", receivesFocus: [0, "receives-focus", "receivesFocus"], slotEl: [0, "slot-el", "slotEl"], state: "state", strategy: "strategy", tipPadding: [0, "tip-padding", "tipPadding"], trigger: "trigger", triggerElement: [0, "trigger-element", "triggerElement"], triggerInteraction: [0, "trigger-interaction", "triggerInteraction"], type: "type" }, outputs: { luzmoOpenedEvent: "luzmo-opened", luzmoClosedEvent: "luzmo-closed", slottableRequestEvent: "slottable-request" }, exportAs: ["luzmoOverlay"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoOverlay_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoOverlay, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-overlay',
+                exportAs: 'luzmoOverlay',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { delayed: [{
+            type: Input,
+            args: [{ alias: 'delayed' }]
+        }], dialogEl: [{
+            type: Input,
+            args: [{ alias: 'dialog-el' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], elements: [{
+            type: Input,
+            args: [{ alias: 'elements' }]
+        }], parentOverlayToForceClose: [{
+            type: Input,
+            args: [{ alias: 'parent-overlay-to-force-close' }]
+        }], offset: [{
+            type: Input,
+            args: [{ alias: 'offset' }]
+        }], open: [{
+            type: Input,
+            args: [{ alias: 'open' }]
+        }], placement: [{
+            type: Input,
+            args: [{ alias: 'placement' }]
+        }], receivesFocus: [{
+            type: Input,
+            args: [{ alias: 'receives-focus' }]
+        }], slotEl: [{
+            type: Input,
+            args: [{ alias: 'slot-el' }]
+        }], state: [{
+            type: Input,
+            args: [{ alias: 'state' }]
+        }], strategy: [{
+            type: Input,
+            args: [{ alias: 'strategy' }]
+        }], tipPadding: [{
+            type: Input,
+            args: [{ alias: 'tip-padding' }]
+        }], trigger: [{
+            type: Input,
+            args: [{ alias: 'trigger' }]
+        }], triggerElement: [{
+            type: Input,
+            args: [{ alias: 'trigger-element' }]
+        }], triggerInteraction: [{
+            type: Input,
+            args: [{ alias: 'trigger-interaction' }]
+        }], type: [{
+            type: Input,
+            args: [{ alias: 'type' }]
+        }], luzmoOpenedEvent: [{ type: i0.Output, args: ["luzmo-opened"] }], luzmoClosedEvent: [{ type: i0.Output, args: ["luzmo-closed"] }], slottableRequestEvent: [{ type: i0.Output, args: ["slottable-request"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoOverlay, { className: "LuzmoOverlay", filePath: "components/overlay.ts", lineNumber: 15 }); })();

package/esm/components/picker-button.d.ts

@@ -0,0 +1,32 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/picker-button';
+import type { LuzmoPickerButton as LuzmoPickerButtonHostElement } from '@luzmo/lucero/picker-button';
+import * as i0 from "@angular/core";
+export declare class LuzmoPickerButton implements OnChanges {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoPickerButtonHostElement;
+    invalid?: boolean;
+    position?: 'left' | 'right';
+    active?: boolean;
+    /** The default behavior of the button. Possible values are: `button` (default), `submit`, and `reset`. */
+    type?: 'button' | 'submit' | 'reset';
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoPickerButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoPickerButton, "luzmo-picker-button", ["luzmoPickerButton"], { "invalid": { "alias": "invalid"; "required": false; }; "position": { "alias": "position"; "required": false; }; "active": { "alias": "active"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoPickerButton */
+export type LuzmoPickerButtonElement = LuzmoPickerButtonHostElement;

package/esm/components/picker-button.js

@@ -0,0 +1,94 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/picker-button';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-picker-button>
+ *
+ * @slot (default) - text content to be displayed in the Button element
+ * @slot icon - icon element(s) to display at the start of the button
+ */
+export class LuzmoPickerButton {
+    elementRef = inject(ElementRef);
+    renderer = inject(Renderer2);
+    destroyRef = inject(DestroyRef);
+    host = this.elementRef.nativeElement;
+    listenerCleanup = [];
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement() {
+        return this.host;
+    }
+    invalid;
+    position;
+    active;
+    /** The default behavior of the button. Possible values are: `button` (default), `submit`, and `reset`. */
+    type;
+    constructor() {
+        this.bindEvents();
+        this.destroyRef.onDestroy(() => {
+            for (const cleanup of this.listenerCleanup) {
+                cleanup();
+            }
+        });
+    }
+    ngOnChanges(changes) {
+        for (const key of Object.keys(changes)) {
+            switch (key) {
+                case 'invalid':
+                    this.setHostProperty('invalid', changes['invalid'].currentValue);
+                    break;
+                case 'position':
+                    this.setHostProperty('position', changes['position'].currentValue);
+                    break;
+                case 'active':
+                    this.setHostProperty('active', changes['active'].currentValue);
+                    break;
+                case 'type':
+                    this.setHostProperty('type', changes['type'].currentValue);
+                    break;
+                default:
+                    break;
+            }
+        }
+    }
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    setHostProperty(key, value) {
+        this.renderer.setProperty(this.host, key, value);
+    }
+    bindEvents() {
+        // No custom events for this wrapper.
+    }
+    static ɵfac = function LuzmoPickerButton_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoPickerButton)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoPickerButton, selectors: [["luzmo-picker-button"]], inputs: { invalid: "invalid", position: "position", active: "active", type: "type" }, exportAs: ["luzmoPickerButton"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoPickerButton_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoPickerButton, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-picker-button',
+                exportAs: 'luzmoPickerButton',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { invalid: [{
+            type: Input,
+            args: [{ alias: 'invalid' }]
+        }], position: [{
+            type: Input,
+            args: [{ alias: 'position' }]
+        }], active: [{
+            type: Input,
+            args: [{ alias: 'active' }]
+        }], type: [{
+            type: Input,
+            args: [{ alias: 'type' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoPickerButton, { className: "LuzmoPickerButton", filePath: "components/picker-button.ts", lineNumber: 18 }); })();

package/esm/components/picker.d.ts

@@ -0,0 +1,79 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import '@luzmo/lucero/picker';
+import type { LuzmoPicker as LuzmoPickerHostElement } from '@luzmo/lucero/picker';
+import * as i0 from "@angular/core";
+export declare class LuzmoPicker implements OnChanges, ControlValueAccessor {
+    private readonly elementRef;
+    private readonly renderer;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly listenerCleanup;
+    /** The underlying custom element instance. Use to call imperative methods. */
+    get nativeElement(): LuzmoPickerHostElement;
+    appliedLabel?: string;
+    button?: unknown;
+    /** Whether the Picker is disabled. */
+    disabled?: boolean;
+    focused?: boolean;
+    icons?: 'only' | 'none';
+    /** Type of dropdown */
+    variant?: 'checkmarks' | 'highlight';
+    /** Whether the value is invalid. */
+    invalid?: boolean;
+    /** Whether the items are currently loading. */
+    pending?: boolean;
+    /** Defines a string value that labels the Picker while it is in pending state. */
+    pendingLabel?: string;
+    label?: string;
+    open?: boolean;
+    /** Readonly value */
+    readonly?: boolean;
+    labelAlignment?: 'inline';
+    optionsMenu?: unknown;
+    overlayElement?: unknown;
+    placement?: "top" | "top-start" | "top-end" | "right" | "right-start" | "right-end" | "bottom" | "bottom-start" | "bottom-end" | "left" | "left-start" | "left-end";
+    /** Display as a quiet picker */
+    quiet?: boolean;
+    value?: string;
+    selectedItem?: unknown;
+    selects?: never | 'single';
+    dependencyManager?: unknown;
+    isMobile?: unknown;
+    strategy?: unknown;
+    pendingStateController?: unknown;
+    handleSlottableRequest?: unknown;
+    applyFocusElementLabel?: unknown;
+    /** Announces that the `value` of the element has changed */
+    readonly changeEvent: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** Announces that the overlay has been opened */
+    readonly luzmoOpenedEvent: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    /** Announces that the overlay has been closed */
+    readonly luzmoClosedEvent: import("@angular/core").OutputEmitterRef<CustomEvent<unknown>>;
+    readonly scrollEvent: import("@angular/core").OutputEmitterRef<Event>;
+    constructor();
+    ngOnChanges(changes: SimpleChanges): void;
+    /**
+     * Forward a wrapper @Input to the underlying host element via Renderer2 so
+     * the wrapper stays compatible with non-DOM Angular platforms (SSR, tests).
+     * Unlike a "skip undefined" guard, this lets consumers reset values back to
+     * undefined / null by clearing their bindings.
+     */
+    private setHostProperty;
+    private bindEvents;
+    private onChange;
+    private onTouched;
+    private isWritingValue;
+    private lastCvaValue;
+    writeValue(value: string): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    focus(options?: FocusOptions): void;
+    toggle(target?: boolean): void;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoPicker, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoPicker, "luzmo-picker", ["luzmoPicker"], { "appliedLabel": { "alias": "applied-label"; "required": false; }; "button": { "alias": "button"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; "icons": { "alias": "icons"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "pending": { "alias": "pending"; "required": false; }; "pendingLabel": { "alias": "pending-label"; "required": false; }; "label": { "alias": "label"; "required": false; }; "open": { "alias": "open"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "labelAlignment": { "alias": "label-alignment"; "required": false; }; "optionsMenu": { "alias": "options-menu"; "required": false; }; "overlayElement": { "alias": "overlay-element"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "quiet": { "alias": "quiet"; "required": false; }; "value": { "alias": "value"; "required": false; }; "selectedItem": { "alias": "selected-item"; "required": false; }; "selects": { "alias": "selects"; "required": false; }; "dependencyManager": { "alias": "dependency-manager"; "required": false; }; "isMobile": { "alias": "is-mobile"; "required": false; }; "strategy": { "alias": "strategy"; "required": false; }; "pendingStateController": { "alias": "pending-state-controller"; "required": false; }; "handleSlottableRequest": { "alias": "handle-slottable-request"; "required": false; }; "applyFocusElementLabel": { "alias": "apply-focus-element-label"; "required": false; }; }, { "changeEvent": "change"; "luzmoOpenedEvent": "luzmo-opened"; "luzmoClosedEvent": "luzmo-closed"; "scrollEvent": "scroll"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoPicker */
+export type LuzmoPickerElement = LuzmoPickerHostElement;