@luzmo/ngx-lucero 2.4.2 → 2.5.0

package/esm/components/table-body.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableBody as LuzmoTableBodyHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableBody 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(): LuzmoTableBodyHostElement;
+    role?: string;
+    /** The body scroll position changed. */
+    readonly luzmoTableBodyScroll: 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<LuzmoTableBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableBody, "luzmo-table-body", ["luzmoTableBody"], { "role": { "alias": "role"; "required": false; }; }, { "luzmoTableBodyScroll": "luzmo-table-body-scroll"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableBody */
+export type LuzmoTableBodyElement = LuzmoTableBodyHostElement;

package/esm/components/table-body.js

@@ -0,0 +1,75 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, output, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-body>
+ *
+ * @slot (default) - `luzmo-table-row` elements.
+ */
+export class LuzmoTableBody {
+    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;
+    }
+    role;
+    /** The body scroll position changed. */
+    luzmoTableBodyScroll = output({ alias: 'luzmo-table-body-scroll' });
+    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 'role':
+                    this.setHostProperty('role', changes['role'].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-table-body-scroll', (event) => {
+            this.luzmoTableBodyScroll.emit(event);
+        }));
+    }
+    static ɵfac = function LuzmoTableBody_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableBody)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableBody, selectors: [["luzmo-table-body"]], inputs: { role: "role" }, outputs: { luzmoTableBodyScroll: "luzmo-table-body-scroll" }, exportAs: ["luzmoTableBody"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableBody_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableBody, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-body',
+                exportAs: 'luzmoTableBody',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], luzmoTableBodyScroll: [{ type: i0.Output, args: ["luzmo-table-body-scroll"] }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableBody, { className: "LuzmoTableBody", filePath: "components/table-body.ts", lineNumber: 17 }); })();

package/esm/components/table-cell.d.ts

@@ -0,0 +1,30 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableCell as LuzmoTableCellHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableCell 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(): LuzmoTableCellHostElement;
+    role?: string;
+    /** Maximum number of lines before the cell truncates. Unset wraps. Overrides the column's `lineClamp`. */
+    lineClamp?: number;
+    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<LuzmoTableCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableCell, "luzmo-table-cell", ["luzmoTableCell"], { "role": { "alias": "role"; "required": false; }; "lineClamp": { "alias": "lineClamp"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableCell */
+export type LuzmoTableCellElement = LuzmoTableCellHostElement;

package/esm/components/table-cell.js

@@ -0,0 +1,79 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-cell>
+ *
+ * @slot (default) - Cell content.
+ */
+export class LuzmoTableCell {
+    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;
+    }
+    role;
+    /** Maximum number of lines before the cell truncates. Unset wraps. Overrides the column's `lineClamp`. */
+    lineClamp;
+    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 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'lineClamp':
+                    this.setHostProperty('lineClamp', changes['lineClamp'].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 LuzmoTableCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableCell)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableCell, selectors: [["luzmo-table-cell"]], inputs: { role: "role", lineClamp: "lineClamp" }, exportAs: ["luzmoTableCell"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableCell_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableCell, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-cell',
+                exportAs: 'luzmoTableCell',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], lineClamp: [{
+            type: Input,
+            args: [{ alias: 'lineClamp' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableCell, { className: "LuzmoTableCell", filePath: "components/table-cell.ts", lineNumber: 17 }); })();

package/esm/components/table-checkbox-cell.d.ts

@@ -0,0 +1,37 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableCheckboxCell as LuzmoTableCheckboxCellHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableCheckboxCell 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(): LuzmoTableCheckboxCellHostElement;
+    role?: string;
+    /** Whether this is the select-all cell of the header row. */
+    headCell?: boolean;
+    checked?: boolean;
+    indeterminate?: boolean;
+    disabled?: boolean;
+    selectsSingle?: boolean;
+    emphasized?: boolean;
+    /** Accessible name of the checkbox. */
+    label?: 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<LuzmoTableCheckboxCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableCheckboxCell, "luzmo-table-checkbox-cell", ["luzmoTableCheckboxCell"], { "role": { "alias": "role"; "required": false; }; "headCell": { "alias": "headCell"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "selectsSingle": { "alias": "selectsSingle"; "required": false; }; "emphasized": { "alias": "emphasized"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableCheckboxCell */
+export type LuzmoTableCheckboxCellElement = LuzmoTableCheckboxCellHostElement;

package/esm/components/table-checkbox-cell.js

@@ -0,0 +1,120 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-checkbox-cell>
+ */
+export class LuzmoTableCheckboxCell {
+    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;
+    }
+    role;
+    /** Whether this is the select-all cell of the header row. */
+    headCell;
+    checked;
+    indeterminate;
+    disabled;
+    selectsSingle;
+    emphasized;
+    /** Accessible name of the checkbox. */
+    label;
+    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 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'headCell':
+                    this.setHostProperty('headCell', changes['headCell'].currentValue);
+                    break;
+                case 'checked':
+                    this.setHostProperty('checked', changes['checked'].currentValue);
+                    break;
+                case 'indeterminate':
+                    this.setHostProperty('indeterminate', changes['indeterminate'].currentValue);
+                    break;
+                case 'disabled':
+                    this.setHostProperty('disabled', changes['disabled'].currentValue);
+                    break;
+                case 'selectsSingle':
+                    this.setHostProperty('selectsSingle', changes['selectsSingle'].currentValue);
+                    break;
+                case 'emphasized':
+                    this.setHostProperty('emphasized', changes['emphasized'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].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 LuzmoTableCheckboxCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableCheckboxCell)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableCheckboxCell, selectors: [["luzmo-table-checkbox-cell"]], inputs: { role: "role", headCell: "headCell", checked: "checked", indeterminate: "indeterminate", disabled: "disabled", selectsSingle: "selectsSingle", emphasized: "emphasized", label: "label" }, exportAs: ["luzmoTableCheckboxCell"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableCheckboxCell_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableCheckboxCell, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-checkbox-cell',
+                exportAs: 'luzmoTableCheckboxCell',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], headCell: [{
+            type: Input,
+            args: [{ alias: 'headCell' }]
+        }], checked: [{
+            type: Input,
+            args: [{ alias: 'checked' }]
+        }], indeterminate: [{
+            type: Input,
+            args: [{ alias: 'indeterminate' }]
+        }], disabled: [{
+            type: Input,
+            args: [{ alias: 'disabled' }]
+        }], selectsSingle: [{
+            type: Input,
+            args: [{ alias: 'selectsSingle' }]
+        }], emphasized: [{
+            type: Input,
+            args: [{ alias: 'emphasized' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableCheckboxCell, { className: "LuzmoTableCheckboxCell", filePath: "components/table-checkbox-cell.ts", lineNumber: 15 }); })();

package/esm/components/table-disclosure-cell.d.ts

@@ -0,0 +1,31 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableDisclosureCell as LuzmoTableDisclosureCellHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableDisclosureCell 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(): LuzmoTableDisclosureCellHostElement;
+    role?: string;
+    expanded?: boolean;
+    /** Accessible name of the disclosure button. */
+    label?: 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<LuzmoTableDisclosureCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableDisclosureCell, "luzmo-table-disclosure-cell", ["luzmoTableDisclosureCell"], { "role": { "alias": "role"; "required": false; }; "expanded": { "alias": "expanded"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableDisclosureCell */
+export type LuzmoTableDisclosureCellElement = LuzmoTableDisclosureCellHostElement;

package/esm/components/table-disclosure-cell.js

@@ -0,0 +1,84 @@
+import { ChangeDetectionStrategy, Component, DestroyRef, ElementRef, inject, Input, Renderer2 } from '@angular/core';
+import '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+const _c0 = ["*"];
+/**
+ * Angular wrapper component for <luzmo-table-disclosure-cell>
+ */
+export class LuzmoTableDisclosureCell {
+    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;
+    }
+    role;
+    expanded;
+    /** Accessible name of the disclosure button. */
+    label;
+    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 'role':
+                    this.setHostProperty('role', changes['role'].currentValue);
+                    break;
+                case 'expanded':
+                    this.setHostProperty('expanded', changes['expanded'].currentValue);
+                    break;
+                case 'label':
+                    this.setHostProperty('label', changes['label'].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 LuzmoTableDisclosureCell_Factory(__ngFactoryType__) { return new (__ngFactoryType__ || LuzmoTableDisclosureCell)(); };
+    static ɵcmp = /*@__PURE__*/ i0.ɵɵdefineComponent({ type: LuzmoTableDisclosureCell, selectors: [["luzmo-table-disclosure-cell"]], inputs: { role: "role", expanded: "expanded", label: "label" }, exportAs: ["luzmoTableDisclosureCell"], features: [i0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function LuzmoTableDisclosureCell_Template(rf, ctx) { if (rf & 1) {
+            i0.ɵɵprojectionDef();
+            i0.ɵɵprojection(0);
+        } }, encapsulation: 2 });
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(LuzmoTableDisclosureCell, [{
+        type: Component,
+        args: [{
+                selector: 'luzmo-table-disclosure-cell',
+                exportAs: 'luzmoTableDisclosureCell',
+                standalone: true,
+                changeDetection: ChangeDetectionStrategy.OnPush,
+                template: '<ng-content />'
+            }]
+    }], () => [], { role: [{
+            type: Input,
+            args: [{ alias: 'role' }]
+        }], expanded: [{
+            type: Input,
+            args: [{ alias: 'expanded' }]
+        }], label: [{
+            type: Input,
+            args: [{ alias: 'label' }]
+        }] }); })();
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassDebugInfo(LuzmoTableDisclosureCell, { className: "LuzmoTableDisclosureCell", filePath: "components/table-disclosure-cell.ts", lineNumber: 15 }); })();

package/esm/components/table-head-cell.d.ts

@@ -0,0 +1,50 @@
+import { OnChanges, SimpleChanges } from '@angular/core';
+import '@luzmo/lucero/table';
+import type { LuzmoTableHeadCell as LuzmoTableHeadCellHostElement } from '@luzmo/lucero/table';
+import * as i0 from "@angular/core";
+export declare class LuzmoTableHeadCell 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(): LuzmoTableHeadCellHostElement;
+    role?: string;
+    /** Pressed state while Space is held on a sortable header. */
+    active?: boolean;
+    /** Whether activating the header sorts the table. */
+    sortable?: boolean;
+    /** Current sort direction. Unset when the column is not sorted. */
+    sortDirection?: ('asc' | 'desc');
+    /** Item key the column sorts by. Sent as `sortKey` in `luzmo-table-sorted`. */
+    sortKey?: string;
+    /** Stable column identifier. Defaults to `sortKey`, then the column index. */
+    columnId?: string;
+    /** Fixed column width, in pixels. */
+    width?: number;
+    /** Minimum column width, in pixels. */
+    minWidth?: number;
+    /** Maximum column width, in pixels. */
+    maxWidth?: number;
+    /** Whether the header shows a resize handle. */
+    resizable?: boolean;
+    /** Maximum number of header lines before the text truncates. Unset wraps. Also the default clamp for the column's cells. */
+    lineClamp?: number;
+    /** A sortable header was activated. `detail` is `{ sortKey, sortDirection }`. Cancel it in data mode to skip the client sort. Cancel it on this header to keep sibling sort directions unchanged. */
+    readonly luzmoTableSorted: 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<LuzmoTableHeadCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LuzmoTableHeadCell, "luzmo-table-head-cell", ["luzmoTableHeadCell"], { "role": { "alias": "role"; "required": false; }; "active": { "alias": "active"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "sortKey": { "alias": "sortKey"; "required": false; }; "columnId": { "alias": "columnId"; "required": false; }; "width": { "alias": "width"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "lineClamp": { "alias": "lineClamp"; "required": false; }; }, { "luzmoTableSorted": "luzmo-table-sorted"; }, never, ["*"], true, never>;
+}
+/** The underlying custom element type for LuzmoTableHeadCell */
+export type LuzmoTableHeadCellElement = LuzmoTableHeadCellHostElement;