@kern-ux-annex/kern-angular-kit/index.d.ts

Angular-Umsetzung der KERN UX-Standard Komponenten

import * as _angular_core from '@angular/core';
import { AfterViewInit, OnChanges, SimpleChanges, TemplateRef } from '@angular/core';
import { ControlValueAccessor } from '@angular/forms';

declare class KernAccordion {
    readonly title: _angular_core.InputSignal<string>;
    readonly open: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernAccordion, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernAccordion, "kern-accordion", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class KernAccordionGroup {
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernAccordionGroup, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernAccordionGroup, "kern-accordion-group", never, {}, {}, never, ["*"], true, never>;
}

declare class KernAlert {
    readonly title: _angular_core.InputSignal<string>;
    readonly variant: _angular_core.InputSignal<"info" | "success" | "warning" | "danger">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernAlert, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernAlert, "kern-alert", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class KernDialog {
    readonly dialogId: _angular_core.InputSignal<string | undefined>;
    readonly title: _angular_core.InputSignal<string>;
    readonly btnCloseLabelText: _angular_core.InputSignal<string>;
    readonly btnPrimaryLabelText: _angular_core.InputSignal<string | null>;
    readonly btnSecondaryLabelText: _angular_core.InputSignal<string | null>;
    readonly cancelEvent: _angular_core.OutputEmitterRef<Event>;
    readonly btnPrimaryClickEvent: _angular_core.OutputEmitterRef<Event>;
    readonly btnSecondaryClickEvent: _angular_core.OutputEmitterRef<Event>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    private readonly dialog;
    showModal(): void;
    closeModal(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernDialog, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernDialog, "kern-dialog", never, { "dialogId": { "alias": "dialogId"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": true; "isSignal": true; }; "btnCloseLabelText": { "alias": "btnCloseLabelText"; "required": false; "isSignal": true; }; "btnPrimaryLabelText": { "alias": "btnPrimaryLabelText"; "required": false; "isSignal": true; }; "btnSecondaryLabelText": { "alias": "btnSecondaryLabelText"; "required": false; "isSignal": true; }; }, { "cancelEvent": "cancelEvent"; "btnPrimaryClickEvent": "btnPrimaryClickEvent"; "btnSecondaryClickEvent": "btnSecondaryClickEvent"; }, never, ["*"], true, never>;
}

declare class KernLoader {
    readonly text: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernLoader, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernLoader, "kern-loader", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernBadge {
    readonly variant: _angular_core.InputSignal<"info" | "success" | "warning" | "danger">;
    readonly icon: _angular_core.InputSignal<string | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernBadge, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernBadge, "kern-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class KernButton {
    readonly variant: _angular_core.InputSignal<"primary" | "secondary" | "tertiary">;
    readonly block: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
    readonly iconLeft: _angular_core.InputSignal<string | null>;
    readonly iconRight: _angular_core.InputSignal<string | null>;
    readonly srOnlyLabel: _angular_core.InputSignal<boolean>;
    readonly clickEvent: _angular_core.OutputEmitterRef<Event>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernButton, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernButton, "kern-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "block": { "alias": "block"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "iconLeft": { "alias": "iconLeft"; "required": false; "isSignal": true; }; "iconRight": { "alias": "iconRight"; "required": false; "isSignal": true; }; "srOnlyLabel": { "alias": "srOnlyLabel"; "required": false; "isSignal": true; }; }, { "clickEvent": "clickEvent"; }, never, ["*"], true, never>;
}

declare class KernCard {
    readonly title: _angular_core.InputSignal<string | null>;
    readonly titleLinkHref: _angular_core.InputSignal<string | null>;
    readonly titleLinkTarget: _angular_core.InputSignal<"_self" | "_blank" | "_parent" | "_top">;
    readonly preline: _angular_core.InputSignal<string | null>;
    readonly subline: _angular_core.InputSignal<string | null>;
    readonly imgSrc: _angular_core.InputSignal<string | null>;
    readonly imgAlt: _angular_core.InputSignal<string | null>;
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    readonly headingLevel: _angular_core.InputSignal<"1" | "2" | "3" | "4" | "5">;
    readonly btnPrimaryLabelText: _angular_core.InputSignal<string | null>;
    readonly btnSecondaryLabelText: _angular_core.InputSignal<string | null>;
    readonly titleLinkClickEvent: _angular_core.OutputEmitterRef<Event>;
    readonly btnPrimaryClickEvent: _angular_core.OutputEmitterRef<Event>;
    readonly btnSecondaryClickEvent: _angular_core.OutputEmitterRef<Event>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernCard, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernCard, "kern-card", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "titleLinkHref": { "alias": "titleLinkHref"; "required": false; "isSignal": true; }; "titleLinkTarget": { "alias": "titleLinkTarget"; "required": false; "isSignal": true; }; "preline": { "alias": "preline"; "required": false; "isSignal": true; }; "subline": { "alias": "subline"; "required": false; "isSignal": true; }; "imgSrc": { "alias": "imgSrc"; "required": false; "isSignal": true; }; "imgAlt": { "alias": "imgAlt"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "btnPrimaryLabelText": { "alias": "btnPrimaryLabelText"; "required": false; "isSignal": true; }; "btnSecondaryLabelText": { "alias": "btnSecondaryLabelText"; "required": false; "isSignal": true; }; }, { "titleLinkClickEvent": "titleLinkClickEvent"; "btnPrimaryClickEvent": "btnPrimaryClickEvent"; "btnSecondaryClickEvent": "btnSecondaryClickEvent"; }, never, ["*"], true, never>;
}

declare class KernDivider {
    readonly ariaHidden: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernDivider, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernDivider, "kern-divider", never, { "ariaHidden": { "alias": "ariaHidden"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernIcon {
    readonly name: _angular_core.InputSignal<string>;
    readonly ariaHidden: _angular_core.InputSignal<boolean>;
    readonly size: _angular_core.InputSignal<"default" | "small" | "large" | "x-large">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernIcon, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernIcon, "kern-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "ariaHidden": { "alias": "ariaHidden"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernLink {
    readonly href: _angular_core.InputSignal<string | null>;
    readonly target: _angular_core.InputSignal<"_self" | "_blank" | "_parent" | "_top">;
    readonly small: _angular_core.InputSignal<boolean>;
    readonly stretched: _angular_core.InputSignal<boolean>;
    readonly iconLeft: _angular_core.InputSignal<string | null>;
    readonly iconRight: _angular_core.InputSignal<string | null>;
    readonly linkDescribedBy: _angular_core.InputSignal<string | null>;
    readonly clickEvent: _angular_core.OutputEmitterRef<Event>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernLink, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernLink, "kern-link", never, { "href": { "alias": "href"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "small": { "alias": "small"; "required": false; "isSignal": true; }; "stretched": { "alias": "stretched"; "required": false; "isSignal": true; }; "iconLeft": { "alias": "iconLeft"; "required": false; "isSignal": true; }; "iconRight": { "alias": "iconRight"; "required": false; "isSignal": true; }; "linkDescribedBy": { "alias": "linkDescribedBy"; "required": false; "isSignal": true; }; }, { "clickEvent": "clickEvent"; }, never, ["*"], true, never>;
}

declare class KernProgress {
    readonly progressId: _angular_core.InputSignal<string | undefined>;
    readonly value: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly label: _angular_core.InputSignal<string | null>;
    readonly labelPosition: _angular_core.InputSignal<"top" | "bottom">;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernProgress, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernProgress, "kern-progress", never, { "progressId": { "alias": "progressId"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelPosition": { "alias": "labelPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernKopfzeile {
    readonly fluid: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernKopfzeile, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernKopfzeile, "kern-kopfzeile", never, { "fluid": { "alias": "fluid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernHeading implements AfterViewInit {
    private readonly elementRef;
    private readonly renderer;
    readonly level: _angular_core.InputSignal<"1" | "2" | "3" | "4" | "5" | "6">;
    readonly size: _angular_core.InputSignal<"small" | "large" | "x-large" | "display" | "medium" | undefined>;
    private readonly cssClass;
    ngAfterViewInit(): void;
    private getDefaultSizeForLevel;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernHeading, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernHeading, "kern-heading", never, { "level": { "alias": "level"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class KernBody {
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    readonly weight: _angular_core.InputSignal<"default" | "bold" | "muted">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernBody, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KernBody, "p[kernBody], span[kernBody]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernTitle {
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernTitle, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KernTitle, "h1[kernTitle], h2[kernTitle], h3[kernTitle], h4[kernTitle], h5[kernTitle], h6[kernTitle], span[kernTitle], caption[kernTitle], p[kernTitle]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernSubline {
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernSubline, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KernSubline, "h1[kernSubline], h2[kernSubline], h3[kernSubline], h4[kernSubline], h5[kernSubline], h6[kernSubline], span[kernSubline], p[kernSubline]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernPreline {
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernPreline, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KernPreline, "h1[kernPreline], h2[kernPreline], h3[kernPreline], h4[kernPreline], h5[kernPreline], h6[kernPreline], span[kernPreline], p[kernPreline]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernLabel implements OnChanges {
    private optionalSpan?;
    private readonly elementRef;
    private readonly renderer;
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    readonly optional: _angular_core.InputSignalWithTransform<boolean, unknown>;
    readonly srOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernLabel, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KernLabel, "label[kernLabel], legend[kernLabel], span[kernLabel], p[kernLabel]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "srOnly": { "alias": "srOnly"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernList {
    readonly size: _angular_core.InputSignal<"default" | "small" | "large">;
    readonly type: _angular_core.InputSignal<"number" | "simple" | "bullet">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernList, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KernList, "ul[kernList], ol[kernList]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ControlValueAccessorDirective<TValue = unknown> implements ControlValueAccessor {
    value: _angular_core.WritableSignal<TValue>;
    disabled: _angular_core.WritableSignal<boolean>;
    onChange: (value: TValue) => void;
    onTouched: () => void;
    changeValue(value: TValue): void;
    markTouched(): void;
    writeValue(value: TValue): void;
    registerOnChange(onChange: (value: TValue) => void): void;
    registerOnTouched(onTouched: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ControlValueAccessorDirective<any>, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ControlValueAccessorDirective<any>, "[kernControlValueAccessor]", never, {}, {}, never, never, true, never>;
}

declare class KernInputCheckbox {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly labelText: _angular_core.InputSignal<string | null>;
    readonly error: _angular_core.InputSignal<boolean>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected onChange(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputCheckbox, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputCheckbox, "kern-input-checkbox", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelTemplate": { "alias": "labelTemplate"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

type DatePart = 'day' | 'month' | 'year';
declare class KernInputDate implements ControlValueAccessor, AfterViewInit {
    readonly fieldsetId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    private readonly dayInput;
    private readonly monthInput;
    private readonly yearInput;
    private day;
    private month;
    private year;
    onChange: (value: string | null) => void;
    onTouched: () => void;
    writeValue(value: string | null): void;
    ngAfterViewInit(): void;
    registerOnChange(fn: (value: string | null) => void): void;
    registerOnTouched(fn: () => void): void;
    protected onKeydown(event: KeyboardEvent, type: DatePart): void;
    protected onInput(event: Event, type: DatePart): void;
    private renderValue;
    protected onBlur(event: Event, type: DatePart): void;
    get value(): string | null;
    protected onPaste(event: ClipboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputDate, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputDate, "kern-input-date", never, { "fieldsetId": { "alias": "fieldsetId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernInputEmail {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxlength: _angular_core.InputSignal<number | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputEmail, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputEmail, "kern-input-email", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputError {
    effectiveId: _angular_core.InputSignal<string>;
    text: _angular_core.InputSignal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputError, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputError, "kern-input-error", never, { "effectiveId": { "alias": "effectiveId"; "required": true; "isSignal": true; }; "text": { "alias": "text"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernInputFile {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly accept: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    private readonly fileInput;
    get fileList(): FileList | null;
    protected onChange(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputFile, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputFile, "kern-input-file", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputHint {
    readonly hint: _angular_core.InputSignalWithTransform<{
        template: TemplateRef<unknown> | null;
        text: string;
    }, string | TemplateRef<unknown>>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputHint, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputHint, "kern-input-hint", never, { "hint": { "alias": "hint"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernInputNumber {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly min: _angular_core.InputSignal<number | null>;
    readonly max: _angular_core.InputSignal<number | null>;
    readonly step: _angular_core.InputSignal<number | null>;
    readonly autocomplete: _angular_core.InputSignal<string | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onInput(event: Event): void;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputNumber, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputNumber, "kern-input-number", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputPassword {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxlength: _angular_core.InputSignal<number | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onInput(event: Event): void;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputPassword, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputPassword, "kern-input-password", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputRadio {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly fieldsetId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly horizontalAlignment: _angular_core.InputSignal<boolean>;
    readonly options: _angular_core.InputSignal<{
        value: string;
        label: string;
    }[]>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputRadio, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputRadio, "kern-input-radio", never, { "fieldsetId": { "alias": "fieldsetId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "horizontalAlignment": { "alias": "horizontalAlignment"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputSelect {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly emptyPlaceholder: _angular_core.InputSignal<string>;
    readonly options: _angular_core.InputSignal<{
        value: string;
        label: string;
    }[]>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onChange(event: Event): void;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputSelect, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputSelect, "kern-input-select", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "emptyPlaceholder": { "alias": "emptyPlaceholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputTel {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxlength: _angular_core.InputSignal<number | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onInput(event: Event): void;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputTel, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputTel, "kern-input-tel", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputText {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly inputmode: _angular_core.InputSignal<"decimal" | "numeric" | null>;
    readonly maxlength: _angular_core.InputSignal<number | null>;
    readonly autocomplete: _angular_core.InputSignal<string | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onInput(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputText, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputText, "kern-input-text", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "inputmode": { "alias": "inputmode"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputTextarea {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxlength: _angular_core.InputSignal<number | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onInput(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputTextarea, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputTextarea, "kern-input-textarea", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernInputUrl {
    protected readonly cva: ControlValueAccessorDirective<any>;
    readonly inputId: _angular_core.InputSignal<string | undefined>;
    readonly labelText: _angular_core.InputSignal<string>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly maxlength: _angular_core.InputSignal<number | null>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly titleText: _angular_core.InputSignal<string | null>;
    readonly placeholder: _angular_core.InputSignal<string | null>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly inputDescribedBy: _angular_core.Signal<string | null>;
    protected onInput(event: Event): void;
    protected onKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernInputUrl, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernInputUrl, "kern-input-url", never, { "inputId": { "alias": "inputId"; "required": false; "isSignal": true; }; "labelText": { "alias": "labelText"; "required": true; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "titleText": { "alias": "titleText"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof ControlValueAccessorDirective; inputs: {}; outputs: {}; }]>;
}

declare class KernFieldset {
    readonly fieldsetId: _angular_core.InputSignal<string | undefined>;
    readonly legendText: _angular_core.InputSignal<string>;
    readonly legendSize: _angular_core.InputSignal<"default" | "small" | "large">;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly hintTemplate: _angular_core.InputSignal<TemplateRef<unknown> | null>;
    readonly hintText: _angular_core.InputSignal<string | null>;
    readonly errorText: _angular_core.InputSignal<string | null>;
    readonly horizontalAlignment: _angular_core.InputSignal<boolean>;
    private readonly generatedId;
    protected readonly effectiveId: _angular_core.Signal<string>;
    protected readonly fieldsetDescribedBy: _angular_core.Signal<string | null>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernFieldset, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernFieldset, "kern-fieldset", never, { "fieldsetId": { "alias": "fieldsetId"; "required": false; "isSignal": true; }; "legendText": { "alias": "legendText"; "required": true; "isSignal": true; }; "legendSize": { "alias": "legendSize"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hintTemplate": { "alias": "hintTemplate"; "required": false; "isSignal": true; }; "hintText": { "alias": "hintText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "horizontalAlignment": { "alias": "horizontalAlignment"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

type KernTableColumn = {
    key: string;
    header: string;
    numeric?: boolean;
};
type KernTableRow = Record<string, unknown>;
declare class KernTable {
    readonly responsive: _angular_core.InputSignal<boolean>;
    readonly small: _angular_core.InputSignal<boolean>;
    readonly striped: _angular_core.InputSignal<boolean>;
    readonly caption: _angular_core.InputSignal<string | null>;
    readonly columns: _angular_core.InputSignal<KernTableColumn[]>;
    readonly data: _angular_core.InputSignal<KernTableRow[]>;
    readonly footer: _angular_core.InputSignal<KernTableRow[] | null>;
    readonly rowHeaderKey: _angular_core.InputSignal<string | null>;
    protected getCellText(row: KernTableRow, key: string): unknown;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernTable, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernTable, "kern-table", never, { "responsive": { "alias": "responsive"; "required": false; "isSignal": true; }; "small": { "alias": "small"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; "footer": { "alias": "footer"; "required": false; "isSignal": true; }; "rowHeaderKey": { "alias": "rowHeaderKey"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernDescriptionList {
    readonly items: _angular_core.InputSignal<{
        term: string;
        description: string;
    }[]>;
    readonly column: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernDescriptionList, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernDescriptionList, "kern-description-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "column": { "alias": "column"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

type KernTasklistData = {
    heading: string;
    items: {
        number?: string | null;
        task: string;
        linkHref?: string | null;
        status?: 'new' | 'incomplete' | 'completed' | 'unavailable';
        statusId?: string | null;
    }[];
};
declare class KernTasklist {
    readonly tasks: _angular_core.InputSignal<KernTasklistData[]>;
    readonly headingLevel: _angular_core.InputSignal<"1" | "2" | "3" | "4" | "5" | "6">;
    readonly linkTarget: _angular_core.InputSignal<"_self" | "_blank" | "_parent" | "_top">;
    private readonly generatedId;
    protected getGeneratedStatusId(taskIndex: number, itemIndex: number): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernTasklist, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernTasklist, "kern-tasklist", never, { "tasks": { "alias": "tasks"; "required": true; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "linkTarget": { "alias": "linkTarget"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class KernSummary {
    readonly titleId: _angular_core.InputSignal<string | undefined>;
    readonly title: _angular_core.InputSignal<string | null>;
    readonly titleNumber: _angular_core.InputSignal<string | null>;
    readonly headingLevel: _angular_core.InputSignal<"1" | "2" | "3" | "4" | "5" | "6">;
    readonly items: _angular_core.InputSignal<{
        term: string;
        description: string;
    }[]>;
    readonly actionLinkHref: _angular_core.InputSignal<string | null>;
    readonly actionLinkTarget: _angular_core.InputSignal<"_self" | "_blank" | "_parent" | "_top">;
    readonly actionLinkClickEvent: _angular_core.OutputEmitterRef<Event>;
    private readonly generatedTitleId;
    protected readonly effectiveTitleId: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernSummary, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernSummary, "kern-summary", never, { "titleId": { "alias": "titleId"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "titleNumber": { "alias": "titleNumber"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": true; "isSignal": true; }; "actionLinkHref": { "alias": "actionLinkHref"; "required": false; "isSignal": true; }; "actionLinkTarget": { "alias": "actionLinkTarget"; "required": false; "isSignal": true; }; }, { "actionLinkClickEvent": "actionLinkClickEvent"; }, never, never, true, never>;
}

declare class KernSummaryGroup {
    readonly heading: _angular_core.InputSignal<string | null>;
    readonly headingLevel: _angular_core.InputSignal<"1" | "2" | "3" | "4" | "5" | "6">;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KernSummaryGroup, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KernSummaryGroup, "kern-summary-group", never, { "heading": { "alias": "heading"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

declare class KernContainer {
    readonly fluid: _angular_core.InputSignal<bool