@luzmo/ngx-lucero 1.0.1-alpha.78

package/esm/components/switch.js

@@ -0,0 +1,160 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, forwardRef, inject, Input, output, Renderer2 } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import '@luzmo/lucero/switch';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-switch>
+ *
+ * @slot (default) - text label of the Switch
+ */
+export class LuzmoSwitch {
+    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;
+    }
+    /** Deliver the Switch with additional visual emphasis. */
+    emphasized;
+    /** Whether the thumb is within the Switch or overflows it. */
+    thumb;
+    /** The `checked` attribute reflects the state of the element */
+    checked;
+    /** The name attribute of the element */
+    name;
+    /** Whether the element is read-only */
+    readonly;
+    /** Announces a change in the `checked` property of a Switch */
+    changeEvent = output({ alias: 'change' });
+    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 'emphasized':
+                    this.setHostProperty('emphasized', changes['emphasized'].currentValue);
+                    break;
+                case 'thumb':
+                    this.setHostProperty('thumb', changes['thumb'].currentValue);
+                    break;
+                case 'checked':
+                    this.setHostProperty('checked', changes['checked'].currentValue);
+                    break;
+                case 'name':
+                    this.setHostProperty('name', changes['name'].currentValue);
+                    break;
+                case 'readonly':
+                    this.setHostProperty('readonly', changes['readonly'].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, 'change', (event) => {
+            this.changeEvent.emit(event);
+            if (!this.isWritingValue) {
+                const eventWithDetail = event;
+                const eventTarget = event.target;
+                const detail = 'detail' in eventWithDetail ? eventWithDetail.detail : undefined;
+                const hostRecord = this.host;
+                const nextValue = (detail
+                    ?? eventTarget?.['checked']
+                    ?? hostRecord['checked']);
+                if (Object.is(this.lastCvaValue, nextValue)) {
+                    return;
+                }
+                this.lastCvaValue = nextValue;
+                this.setHostProperty('checked', nextValue);
+                this.onChange(nextValue);
+            }
+        }));
+        this.listenerCleanup.push(this.renderer.listen(this.host, 'blur', () => {
+            this.onTouched();
+        }));
+    }
+    onChange = () => { };
+    onTouched = () => { };
+    isWritingValue = false;
+    lastCvaValue;
+    writeValue(value) {
+        this.isWritingValue = true;
+        this.lastCvaValue = value;
+        this.setHostProperty('checked', value);
+        this.isWritingValue = false;
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    setDisabledState(isDisabled) {
+        // Underlying element does not declare a 'disabled' field; nothing to do.
+        void isDisabled;
+    }
+    static ɵfac = function LuzmoSwitch_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoSwitch)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoSwitch, selectors: [["luzmo-switch"]], inputs: { emphasized: "emphasized", thumb: "thumb", checked: "checked", name: "name", readonly: "readonly" }, outputs: { changeEvent: "change" }, exportAs: ["luzmoSwitch"], features: [i0.ɵɵProvidersFeature([
+                {
+                    provide: NG_VALUE_ACCESSOR,
+                    useExisting: forwardRef(() => LuzmoSwitch),
+                    multi: true
+                }
+            ]), i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoSwitch_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoSwitch, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-switch',
+                exportAs: 'luzmoSwitch',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />',
+                providers: [
+                    {
+                        provide: NG_VALUE_ACCESSOR,
+                        useExisting: forwardRef(() => LuzmoSwitch),
+                        multi: true
+                    }
+                ]
+            }]
+    }], () => [], { emphasized: [{
+            type: Input,
+            args: [{ alias: 'emphasized' }]
+        }], thumb: [{
+            type: Input,
+            args: [{ alias: 'thumb' }]
+        }], checked: [{
+            type: Input,
+            args: [{ alias: 'checked' }]
+        }], name: [{
+            type: Input,
+            args: [{ alias: 'name' }]
+        }], readonly: [{
+            type: Input,
+            args: [{ alias: 'readonly' }]
+        }], changeEvent: [{ type: i0.Output, args: ["change"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoSwitch, { className: "LuzmoSwitch", filePath: "components/switch.ts", lineNumber: 25 }); })();

package/esm/components/tab-panel.d.ts

@@ -0,0 +1,29 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import type { LuzmoTabPanel as LuzmoTabPanelHostElement } from '@luzmo/lucero/tabs';
+import * as i0 from "@angular/core";
+export declare class LuzmoTabPanel 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(): LuzmoTabPanelHostElement;
+    selected?: boolean;
+    value?: string;
+    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<LuzmoTabPanel, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTabPanel, "luzmo-tab-panel", ["luzmoTabPanel"], { "selected": { "alias": "selected"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTabPanel */
+export type LuzmoTabPanelElement = LuzmoTabPanelHostElement;

package/esm/components/tab-panel.js

@@ -0,0 +1,78 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-tab-panel>
+ *
+ * @slot (default) - content of the Tab Panel
+ */
+export class LuzmoTabPanel {
+    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;
+    }
+    selected;
+    value;
+    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 'selected':
+                    this.setHostProperty('selected', changes['selected'].currentValue);
+                    break;
+                case 'value':
+                    this.setHostProperty('value', changes['value'].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 LuzmoTabPanel_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTabPanel)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTabPanel, selectors: [["luzmo-tab-panel"]], inputs: { selected: "selected", value: "value" }, exportAs: ["luzmoTabPanel"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTabPanel_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTabPanel, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-tab-panel',
+                exportAs: 'luzmoTabPanel',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { selected: [{
+            type: Input,
+            args: [{ alias: 'selected' }]
+        }], value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTabPanel, { className: "LuzmoTabPanel", filePath: "components/tab-panel.ts", lineNumber: 17 }); })();

package/esm/components/tab.d.ts

@@ -0,0 +1,32 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import type { LuzmoTab as LuzmoTabHostElement } from '@luzmo/lucero/tabs';
+import * as i0 from "@angular/core";
+export declare class LuzmoTab 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(): LuzmoTabHostElement;
+    disabled?: boolean;
+    label?: string;
+    selected?: boolean;
+    vertical?: boolean;
+    value?: string;
+    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<LuzmoTab, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTab, "luzmo-tab", ["luzmoTab"], { "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTab */
+export type LuzmoTabElement = LuzmoTabHostElement;

package/esm/components/tab.js

@@ -0,0 +1,100 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-tab>
+ *
+ * @slot (default) - text label of the Tab
+ * @slot icon - The icon that appears on the left of the label
+ */
+export class LuzmoTab {
+    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;
+    }
+    disabled;
+    label;
+    selected;
+    vertical;
+    value;
+    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 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].currentValue);
+                    break;
+                case 'selected':
+                    this.setHostProperty('selected', changes['selected'].currentValue);
+                    break;
+                case 'vertical':
+                    this.setHostProperty('vertical', changes['vertical'].currentValue);
+                    break;
+                case 'value':
+                    this.setHostProperty('value', changes['value'].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 LuzmoTab_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTab)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTab, selectors: [["luzmo-tab"]], inputs: { disabled: "disabled", label: "label", selected: "selected", vertical: "vertical", value: "value" }, exportAs: ["luzmoTab"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTab_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTab, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-tab',
+                exportAs: 'luzmoTab',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }], selected: [{
+            type: Input,
+            args: [{ alias: 'selected' }]
+        }], vertical: [{
+            type: Input,
+            args: [{ alias: 'vertical' }]
+        }], value: [{
+            type: Input,
+            args: [{ alias: 'value' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTab, { className: "LuzmoTab", filePath: "components/tab.ts", lineNumber: 18 }); })();

package/esm/components/tabs-overflow.d.ts

@@ -0,0 +1,33 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import type { LuzmoTabsOverflow as LuzmoTabsOverflowHostElement } from '@luzmo/lucero/tabs';
+import type { ResizeController as __extt_ResizeController } from '@lit-labs/observers/resize-controller.js';
+import * as i0 from "@angular/core";
+export declare class LuzmoTabsOverflow 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(): LuzmoTabsOverflowHostElement;
+    compact?: boolean;
+    labelPrevious?: string;
+    labelNext?: string;
+    dir?: 'ltr' | 'rtl';
+    resizeController?: __extt_ResizeController;
+    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<LuzmoTabsOverflow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTabsOverflow, "luzmo-tabs-overflow", ["luzmoTabsOverflow"], { "compact": { "alias": "compact"; "required": false; }; "labelPrevious": { "alias": "label-previous"; "required": false; }; "labelNext": { "alias": "label-next"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "resizeController": { "alias": "resize-controller"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTabsOverflow */
+export type LuzmoTabsOverflowElement = LuzmoTabsOverflowHostElement;

package/esm/components/tabs-overflow.js

@@ -0,0 +1,97 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-tabs-overflow>
+ */
+export class LuzmoTabsOverflow {
+    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;
+    }
+    compact;
+    labelPrevious;
+    labelNext;
+    dir;
+    resizeController;
+    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 'compact':
+                    this.setHostProperty('compact', changes['compact'].currentValue);
+                    break;
+                case 'labelPrevious':
+                    this.setHostProperty('labelPrevious', changes['labelPrevious'].currentValue);
+                    break;
+                case 'labelNext':
+                    this.setHostProperty('labelNext', changes['labelNext'].currentValue);
+                    break;
+                case 'dir':
+                    this.setHostProperty('dir', changes['dir'].currentValue);
+                    break;
+                case 'resizeController':
+                    this.setHostProperty('resizeController', changes['resizeController'].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 LuzmoTabsOverflow_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTabsOverflow)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTabsOverflow, selectors: [["luzmo-tabs-overflow"]], inputs: { compact: "compact", labelPrevious: [0, "label-previous", "labelPrevious"], labelNext: [0, "label-next", "labelNext"], dir: "dir", resizeController: [0, "resize-controller", "resizeController"] }, exportAs: ["luzmoTabsOverflow"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTabsOverflow_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2, changeDetection: 0 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTabsOverflow, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-tabs-overflow',
+                exportAs: 'luzmoTabsOverflow',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { compact: [{
+            type: Input,
+            args: [{ alias: 'compact' }]
+        }], labelPrevious: [{
+            type: Input,
+            args: [{ alias: 'label-previous' }]
+        }], labelNext: [{
+            type: Input,
+            args: [{ alias: 'label-next' }]
+        }], dir: [{
+            type: Input,
+            args: [{ alias: 'dir' }]
+        }], resizeController: [{
+            type: Input,
+            args: [{ alias: 'resize-controller' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTabsOverflow, { className: "LuzmoTabsOverflow", filePath: "components/tabs-overflow.ts", lineNumber: 16 }); })();

package/esm/components/tabs.d.ts

@@ -0,0 +1,43 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/tabs';
+import type { LuzmoTabs as LuzmoTabsHostElement } from '@luzmo/lucero/tabs';
+import * as i0 from "@angular/core";
+export declare class LuzmoTabs 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(): LuzmoTabsHostElement;
+    /** Whether to activate a tab on keyboard focus or not.  By default a tab is activated via a "click" interaction. This is specifically intended for when tab content cannot be displayed instantly, e.g. not all of the DOM content is available, etc. To learn more about "Deciding When to Make Selection Automatically Follow Focus", visit: https://w3c.github.io/aria-practices/#kbd_selection_follows_focus */
+    auto?: boolean;
+    /** The tab items are displayed closer together. */
+    compact?: boolean;
+    dir?: 'ltr' | 'rtl';
+    direction?: 'vertical' | 'vertical-right' | 'horizontal';
+    emphasized?: boolean;
+    label?: string;
+    enableTabsScroll?: boolean;
+    /** The tab list is displayed without a border. */
+    quiet?: boolean;
+    selectionIndicatorStyle?: unknown;
+    shouldAnimate?: boolean;
+    selected?: string;
+    /** The selected Tab child has changed. */
+    readonly changeEvent: 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;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LuzmoTabs, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTabs, "luzmo-tabs", ["luzmoTabs"], { "auto": { "alias": "auto"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "direction": { "alias": "direction"; "required": false; }; "emphasized": { "alias": "emphasized"; "required": false; }; "label": { "alias": "label"; "required": false; }; "enableTabsScroll": { "alias": "enable-tabs-scroll"; "required": false; }; "quiet": { "alias": "quiet"; "required": false; }; "selectionIndicatorStyle": { "alias": "selection-indicator-style"; "required": false; }; "shouldAnimate": { "alias": "should-animate"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, { "changeEvent": "change"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTabs */
+export type LuzmoTabsElement = LuzmoTabsHostElement;