@konce-pt/angular 0.1.0

package/dist/types/konce-pt-angular.d.ts

@@ -0,0 +1,1858 @@
+import * as _angular_core from '@angular/core';
+import { TemplateRef, OnDestroy } from '@angular/core';
+import { FormValueControl, WithOptionalFieldTree, ValidationError, FormCheckboxControl } from '@angular/forms/signals';
+import { ConnectedPosition } from '@angular/cdk/overlay';
+import * as _konce_pt_angular from '@konce-pt/angular';
+
+type KptButtonVariant = 'filled' | 'tonal' | 'outline' | 'text' | 'danger';
+type KptButtonSize = 'sm' | 'md' | 'lg';
+/**
+ * Przycisk Koncept UI. Renderuje natywny `<button>` (zachowana semantyka i submit
+ * formularza). Wygląd sterowany tokenami `--kpt-button-*`.
+ *
+ * @example
+ * <kpt-button variant="filled" (click)="save()">Zapisz</kpt-button>
+ * <kpt-button variant="outline" size="sm" [disabled]="busy()">Anuluj</kpt-button>
+ */
+declare class KptButton {
+    /** Wariant wizualny. */
+    readonly variant: _angular_core.InputSignal<KptButtonVariant>;
+    /** Rozmiar. */
+    readonly size: _angular_core.InputSignal<KptButtonSize>;
+    /** Typ natywnego przycisku (istotne w formularzach). */
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    /** Wyłączony. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Stan ładowania — pokazuje spinner i blokuje interakcję. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Rozciągnięcie na całą szerokość kontenera. */
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptButton, "kpt-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Przycisk ikonowy (tylko ikona). Wymaga `ariaLabel` dla dostępności.
+ *
+ * @example
+ * <kpt-icon-button ariaLabel="Ustawienia"><kpt-icon name="menu" /></kpt-icon-button>
+ * <kpt-icon-button variant="filled" shape="square" ariaLabel="Usuń"><kpt-icon name="x" /></kpt-icon-button>
+ */
+declare class KptIconButton {
+    readonly variant: _angular_core.InputSignal<KptButtonVariant>;
+    readonly size: _angular_core.InputSignal<KptButtonSize>;
+    readonly shape: _angular_core.InputSignal<"round" | "square">;
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Etykieta dostępności (wymagana — przycisk nie ma tekstu). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    protected readonly isDisabled: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptIconButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptIconButton, "kpt-icon-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** Opcja wyboru dla kontrolek typu select / radio-group. */
+interface KptOption<T = unknown> {
+    label: string;
+    value: T;
+    disabled?: boolean;
+}
+
+/**
+ * Segmentowana grupa przycisków (toggle) — pojedynczy wybór z opcji. Signal Forms.
+ *
+ * @example
+ * <kpt-button-group [(value)]="view" [options]="[{label:'Lista',value:'list'},{label:'Siatka',value:'grid'}]" />
+ * <kpt-button-group [formField]="f.period" [options]="periods" />
+ */
+declare class KptButtonGroup<T = unknown> implements FormValueControl<T> {
+    readonly options: _angular_core.InputSignal<KptOption<T>[]>;
+    readonly value: _angular_core.ModelSignal<T>;
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg">;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected select(opt: KptOption<T>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptButtonGroup<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptButtonGroup<any>, "kpt-button-group", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Floating Action Button (FAB) — okrągły, wyniesiony przycisk akcji. Wariant `extended` = pigułka z tekstem.
+ *
+ * @example
+ * <kpt-fab ariaLabel="Dodaj"><kpt-icon name="plus" /></kpt-fab>
+ * <kpt-fab extended><kpt-icon name="plus" /> Nowy</kpt-fab>
+ */
+declare class KptFab {
+    readonly variant: _angular_core.InputSignal<"filled" | "tonal">;
+    readonly size: _angular_core.InputSignal<"md" | "mini">;
+    readonly extended: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    /** Wymagane dla wariantu okrągłego (bez tekstu). */
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptFab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptFab, "kpt-fab", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "extended": { "alias": "extended"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface KptMenuItem<T = unknown> {
+    label?: string;
+    value?: T;
+    icon?: string;
+    disabled?: boolean;
+    danger?: boolean;
+    separator?: boolean;
+    /** Pozycje podrzędne (menubar / megamenu). */
+    items?: KptMenuItem<T>[];
+    /** Adres odnośnika (menubar / megamenu). */
+    url?: string;
+}
+/**
+ * Menu rozwijane (dropdown) na CDK Overlay. Trigger przez projekcję, pozycje przez `items`.
+ * Wymaga stylów overlay CDK: `import '@angular/cdk/overlay-prebuilt.css';`
+ *
+ * @example
+ * <kpt-menu [items]="items" (select)="onSelect($event)">
+ *   <kpt-button variant="outline">Opcje</kpt-button>
+ * </kpt-menu>
+ */
+declare class KptMenu<T = unknown> {
+    readonly items: _angular_core.InputSignal<KptMenuItem<T>[]>;
+    readonly select: _angular_core.OutputEmitterRef<KptMenuItem<T>>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly positions: ConnectedPosition[];
+    protected toggle(): void;
+    protected close(): void;
+    protected pick(item: KptMenuItem<T>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMenu<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMenu<any>, "kpt-menu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Przycisk dzielony (split button) — akcja główna + rozwijane menu dodatkowych akcji.
+ * Wymaga `import '@angular/cdk/overlay-prebuilt.css';`
+ *
+ * @example
+ * <kpt-split-button [items]="items" (primaryClick)="save()" (select)="onItem($event)">Zapisz</kpt-split-button>
+ */
+declare class KptSplitButton<T = unknown> {
+    readonly variant: _angular_core.InputSignal<KptButtonVariant>;
+    readonly items: _angular_core.InputSignal<KptMenuItem<T>[]>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly primaryClick: _angular_core.OutputEmitterRef<void>;
+    readonly select: _angular_core.OutputEmitterRef<KptMenuItem<T>>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly positions: ConnectedPosition[];
+    protected pick(item: KptMenuItem<T>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSplitButton<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSplitButton<any>, "kpt-split-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "primaryClick": "primaryClick"; "select": "select"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Ikona Koncept UI (inline SVG, zestaw Tabler Icons — MIT). Rozmiar dziedziczy z `font-size`
+ * (1em) lub ustaw `size`; kolor z `currentColor`. Ikona musi być w rejestrze
+ * ([[KptIconRegistry]]) — wbudowany zestaw działa od razu, pełny zestaw dodaje
+ * `provideKptTablerIcons()` z `@konce-pt/angular/icons`.
+ *
+ * @example
+ * <kpt-icon name="menu" />
+ * <kpt-icon name="check" size="1.25rem" />
+ */
+declare class KptIcon {
+    /** Nazwa ikony z rejestru (wbudowana lub zarejestrowana). */
+    readonly name: _angular_core.InputSignal<string>;
+    /** Rozmiar jako długość CSS (np. '1.25rem'); domyślnie dziedziczy z font-size. */
+    readonly size: _angular_core.InputSignal<string>;
+    private readonly host;
+    private readonly registry;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptIcon, "kpt-icon", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Rejestr ikon dla `kpt-icon`. Zawiera wbudowany zestaw (używany przez komponenty).
+ * Aby dodać pełny zestaw Tabler (5130 ikon), użyj `provideKptTablerIcons()`
+ * z `@konce-pt/angular/icons` lub zarejestruj własne przez `register()`.
+ */
+declare class KptIconRegistry {
+    private readonly icons;
+    private readonly _version;
+    /** Rośnie po każdej rejestracji — pozwala `kpt-icon` reagować na późne dodanie ikon. */
+    readonly version: _angular_core.Signal<number>;
+    /** Rejestruje (lub nadpisuje) ikony: `{ nazwa: 'inner svg' }`. */
+    register(icons: Record<string, string>): void;
+    /** Zwraca wewnętrzny SVG ikony lub undefined. */
+    get(name: string): string | undefined;
+    has(name: string): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptIconRegistry, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KptIconRegistry>;
+}
+
+type KptIconName = 'menu' | 'x' | 'chevron-up' | 'chevron-down' | 'chevron-left' | 'chevron-right' | 'check' | 'search' | 'grip-vertical' | 'info' | 'alert-triangle' | 'circle-check' | 'circle-x' | 'calendar' | 'copy' | 'link' | 'code' | 'bold' | 'italic' | 'underline' | 'strikethrough' | 'list' | 'list-numbers' | 'clear-formatting' | 'star' | 'plus' | 'upload' | 'dots-vertical' | 'photo' | 'trash' | 'eye' | 'eye-off' | 'minus' | 'arrow-up' | 'arrow-down' | 'zoom-in' | 'info-circle';
+
+type KptBadgeVariant = 'neutral' | 'primary' | 'success' | 'danger' | 'warning' | 'info';
+/**
+ * Znacznik (badge) — licznik lub kropka statusu. Standalone lub nałożony na treść (`overlay`).
+ *
+ * @example
+ * <kpt-badge [value]="3" variant="danger" />
+ * <kpt-badge [value]="128" overlay><kpt-icon name="menu" /></kpt-badge>
+ * <kpt-badge dot variant="success" overlay><kpt-avatar name="AK" /></kpt-badge>
+ */
+declare class KptBadge {
+    readonly value: _angular_core.InputSignal<string | number | null>;
+    readonly variant: _angular_core.InputSignal<KptBadgeVariant>;
+    readonly dot: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly overlay: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly max: _angular_core.InputSignal<number>;
+    protected readonly display: _angular_core.Signal<string | number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptBadge, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptBadge, "kpt-badge", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "dot": { "alias": "dot"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type KptChipVariant = 'neutral' | 'primary' | 'success' | 'danger' | 'warning' | 'info';
+/**
+ * Chip / tag — etykieta, opcjonalnie usuwalna.
+ *
+ * @example
+ * <kpt-chip>Angular</kpt-chip>
+ * <kpt-chip variant="success" removable (removed)="onRemove()">UI</kpt-chip>
+ */
+declare class KptChip {
+    readonly variant: _angular_core.InputSignal<KptChipVariant>;
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly removed: _angular_core.OutputEmitterRef<void>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChip, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChip, "kpt-chip", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
+}
+
+type KptAvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+type KptAvatarShape = 'circle' | 'square';
+/**
+ * Awatar — obraz, inicjały (z `name`) lub ikona.
+ *
+ * @example
+ * <kpt-avatar src="/u/anna.jpg" />
+ * <kpt-avatar name="Anna Kowalska" size="lg" />
+ * <kpt-avatar icon="user" shape="square" />
+ */
+declare class KptAvatar {
+    readonly src: _angular_core.InputSignal<string | null>;
+    readonly name: _angular_core.InputSignal<string>;
+    readonly icon: _angular_core.InputSignal<string | null>;
+    readonly size: _angular_core.InputSignal<KptAvatarSize>;
+    readonly shape: _angular_core.InputSignal<KptAvatarShape>;
+    protected readonly initials: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAvatar, "kpt-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Wskaźnik ładowania (spinner). Kolor z `currentColor`.
+ *
+ * @example
+ * <kpt-spinner />
+ * <kpt-spinner size="2rem" label="Wczytywanie danych" />
+ */
+declare class KptSpinner {
+    readonly size: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSpinner, "kpt-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type KptProgressVariant = 'primary' | 'success' | 'danger' | 'warning' | 'info';
+/**
+ * Wskaźnik postępu — liniowy lub kołowy, określony (0–100) lub nieokreślony (`value` = null).
+ *
+ * @example
+ * <kpt-progress [value]="60" />
+ * <kpt-progress type="circular" [value]="75" variant="success" />
+ * <kpt-progress [value]="null" />  <!-- indeterminate -->
+ */
+declare class KptProgress {
+    /** 0–100 lub null = nieokreślony. */
+    readonly value: _angular_core.InputSignal<number | null>;
+    readonly variant: _angular_core.InputSignal<KptProgressVariant>;
+    readonly type: _angular_core.InputSignal<"linear" | "circular">;
+    readonly diameter: _angular_core.InputSignal<number>;
+    protected readonly circumference: number;
+    protected readonly offset: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptProgress, "kpt-progress", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "diameter": { "alias": "diameter"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type KptSkeletonVariant = 'text' | 'circle' | 'rect';
+/**
+ * Placeholder ładowania (skeleton) z animacją shimmer.
+ *
+ * @example
+ * <kpt-skeleton variant="text" [lines]="3" />
+ * <kpt-skeleton variant="circle" width="3rem" height="3rem" />
+ * <kpt-skeleton variant="rect" width="100%" height="8rem" />
+ */
+declare class KptSkeleton {
+    readonly variant: _angular_core.InputSignal<KptSkeletonVariant>;
+    readonly width: _angular_core.InputSignal<string>;
+    readonly height: _angular_core.InputSignal<string>;
+    readonly lines: _angular_core.InputSignal<number>;
+    protected readonly lineArray: _angular_core.Signal<unknown[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSkeleton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSkeleton, "kpt-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "lines": { "alias": "lines"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Wrapper pola formularza: etykieta, podpowiedź i komunikat błędu wokół dowolnej
+ * kontrolki (np. `kpt-input`). Prezentacyjny — stan błędu przekazuje się przez `error`
+ * (zwykle z pola Signal Forms). Wygląd sterowany tokenami `--kpt-form-field-*`.
+ *
+ * @example
+ * <kpt-form-field label="E-mail" [error]="emailError()" hint="Firmowy adres">
+ *   <kpt-input [control]="f.email" type="email" />
+ * </kpt-form-field>
+ */
+declare class KptFormField {
+    /** Tekst etykiety. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Podpowiedź pod kontrolką (ukrywana, gdy jest błąd). */
+    readonly hint: _angular_core.InputSignal<string>;
+    /** Komunikat błędu — gdy niepusty, pole jest oznaczone jako nieprawidłowe. */
+    readonly error: _angular_core.InputSignal<string | null>;
+    /** Oznacz pole jako wymagane (gwiazdka przy etykiecie). */
+    readonly required: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Id kontrolki dla powiązania `label[for]`. */
+    readonly controlId: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptFormField, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptFormField, "kpt-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type KptInputType = 'text' | 'email' | 'password' | 'number' | 'search' | 'tel' | 'url';
+/**
+ * Pole tekstowe Koncept UI zintegrowane z Angular Signal Forms.
+ * Implementuje `FormValueControl<string>` — wiąż je dyrektywą `FormField`:
+ *
+ *   <kpt-input [formField]="loginForm.email" type="email" />
+ *
+ * Stan pola (disabled/readonly/required/invalid/errors/touched) wiąże automatycznie
+ * dyrektywa `FormField`. Bez `ControlValueAccessor`. Wygląd: tokeny `--kpt-form-field-*`.
+ */
+declare class KptInput implements FormValueControl<string> {
+    /** Wartość pola (wymagane przez kontrakt FormValueControl). */
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readonly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalFieldTree<ValidationError>[]>;
+    readonly touched: _angular_core.InputSignal<boolean>;
+    /** Emitowane na `blur` — oznacza pole jako dotknięte. */
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly type: _angular_core.InputSignal<KptInputType>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly id: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    protected onInput(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptInput, "kpt-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pole wyboru (checkbox) zintegrowane z Signal Forms (`FormCheckboxControl`).
+ * Wiąż dyrektywą `FormField`: `<kpt-checkbox [formField]="f.terms" label="Akceptuję" />`.
+ */
+declare class KptCheckbox implements FormCheckboxControl {
+    /** Zaznaczenie (wymagane przez kontrakt FormCheckboxControl). */
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    /** Etykieta obok pola. */
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptCheckbox, "kpt-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touch": "touch"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Przełącznik (switch/toggle) zintegrowany z Signal Forms (`FormCheckboxControl`).
+ * `<kpt-switch [formField]="f.notifications" label="Powiadomienia" />`
+ */
+declare class KptSwitch implements FormCheckboxControl {
+    readonly checked: _angular_core.ModelSignal<boolean>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly label: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSwitch, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSwitch, "kpt-switch", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "touch": "touch"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Grupa przycisków opcji (radio) zintegrowana z Signal Forms (`FormValueControl<T>`).
+ * Opcje przez `options`. `<kpt-radio-group [formField]="f.plan" [options]="plans" />`
+ */
+declare class KptRadioGroup<T = unknown> implements FormValueControl<T> {
+    readonly value: _angular_core.ModelSignal<T>;
+    readonly options: _angular_core.InputSignal<KptOption<T>[]>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly name: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptRadioGroup<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptRadioGroup<any>, "kpt-radio-group", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Lista wyboru (select) na własnym panelu (CDK Overlay), zintegrowana z Signal Forms.
+ * Warianty: pojedynczy, z wyszukiwarką (`filter`) i wielokrotny (`multiple`, chipy).
+ *
+ * @example
+ * <kpt-select [formField]="f.role" [options]="roles" placeholder="Wybierz…" />
+ * <kpt-select [formField]="f.city" [options]="cities" filter placeholder="Szukaj miasta…" />
+ * <kpt-select [formField]="f.tags" [options]="tags" multiple filter placeholder="Tagi…" />
+ */
+declare class KptSelect<T = unknown> implements FormValueControl<unknown> {
+    readonly options: _angular_core.InputSignal<KptOption<T>[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Wartość: pojedyncza (T) lub tablica (T[]) w trybie multiple. */
+    readonly value: _angular_core.ModelSignal<unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly positions: ConnectedPosition[];
+    private readonly selectedValues;
+    protected readonly selectedOptions: _angular_core.Signal<KptOption<T>[]>;
+    protected readonly filteredOptions: _angular_core.Signal<KptOption<T>[]>;
+    protected readonly singleLabel: _angular_core.Signal<string>;
+    protected readonly hasValue: _angular_core.Signal<boolean>;
+    protected isSelected(opt: KptOption<T>): boolean;
+    protected toggleOpen(): void;
+    protected close(): void;
+    protected pick(opt: KptOption<T>): void;
+    protected removeChip(opt: KptOption<T>, event: Event): void;
+    protected onFilterInput(event: Event): void;
+    protected onTriggerKeydown(event: KeyboardEvent): void;
+    protected onPanelKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSelect<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSelect<any>, "kpt-select", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+interface DayCell$1 {
+    day: number;
+    iso: string;
+    inMonth: boolean;
+    today: boolean;
+    selected: boolean;
+    disabled: boolean;
+}
+/**
+ * Wybór daty z własnym kalendarzem (CDK Overlay), Signal Forms. Wartość ISO 'RRRR-MM-DD'.
+ * Wymaga stylów overlay CDK: `import '@angular/cdk/overlay-prebuilt.css';`
+ *
+ * @example
+ * <kpt-datepicker [formField]="f.birthDate" minDate="1900-01-01" />
+ */
+declare class KptDatepicker implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly minDate: _angular_core.InputSignal<string | null>;
+    readonly maxDate: _angular_core.InputSignal<string | null>;
+    protected readonly weekdays: string[];
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    private readonly today;
+    private readonly view;
+    protected readonly positions: ConnectedPosition[];
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    protected readonly display: _angular_core.Signal<string>;
+    protected readonly weeks: _angular_core.Signal<DayCell$1[][]>;
+    private parse;
+    protected toggleOpen(): void;
+    protected close(): void;
+    protected selectDay(cell: DayCell$1): void;
+    protected prevMonth(): void;
+    protected nextMonth(): void;
+    protected clear(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDatepicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDatepicker, "kpt-datepicker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pole wieloliniowe (textarea) na Signal Forms, z opcjonalnym auto-resize.
+ *
+ * @example
+ * <kpt-textarea [formField]="f.notes" placeholder="Notatki…" autoResize />
+ */
+declare class KptTextarea implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly autoResize: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    private readonly ta;
+    constructor();
+    protected onInput(event: Event): void;
+    private resize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptTextarea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptTextarea, "kpt-textarea", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "autoResize": { "alias": "autoResize"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+type KptRichTool = 'bold' | 'italic' | 'underline' | 'strike' | 'ul' | 'ol' | 'link' | 'clear';
+/**
+ * Lekki edytor tekstu sformatowanego (contenteditable) z konfigurowalnym paskiem przycisków.
+ * Wartość = HTML. Bez zależności zewnętrznych. Signal Forms.
+ *
+ * @example
+ * <kpt-rich-text [formField]="f.body" [toolbar]="['bold','italic','ul','link']" />
+ */
+declare class KptRichText implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly toolbar: _angular_core.InputSignal<KptRichTool[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    private readonly editor;
+    constructor();
+    protected icon(item: KptRichTool): KptIconName;
+    protected onInput(): void;
+    protected exec(item: KptRichTool): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptRichText, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptRichText, "kpt-rich-text", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "toolbar": { "alias": "toolbar"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Suwak wartości (slider) na Signal Forms.
+ *
+ * @example
+ * <kpt-slider [formField]="f.volume" [min]="0" [max]="100" [step]="5" showValue />
+ */
+declare class KptSlider implements FormValueControl<number> {
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly percent: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSlider, "kpt-slider", never, { "value": { "alias": "value"; "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; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Ocena gwiazdkami (rating) na Signal Forms.
+ *
+ * @example
+ * <kpt-rating [formField]="f.score" [max]="5" />
+ * <kpt-rating [value]="4" readonly />
+ */
+declare class KptRating implements FormValueControl<number> {
+    readonly value: _angular_core.ModelSignal<number>;
+    /** Liczba gwiazdek. */
+    readonly count: _angular_core.InputSignal<number>;
+    readonly readonly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly hover: _angular_core.WritableSignal<number>;
+    protected readonly stars: _angular_core.Signal<number[]>;
+    protected pick(star: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptRating, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptRating, "kpt-rating", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Wgrywanie plików (drag-drop + wybór). Wartość = File[]. Signal Forms.
+ *
+ * @example
+ * <kpt-file-upload [formField]="f.files" accept="image/*" multiple />
+ */
+declare class KptFileUpload implements FormValueControl<File[]> {
+    readonly value: _angular_core.ModelSignal<File[]>;
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly dragover: _angular_core.WritableSignal<boolean>;
+    protected onSelect(event: Event): void;
+    protected onDragOver(event: DragEvent): void;
+    protected onDrop(event: DragEvent): void;
+    private addFiles;
+    protected remove(file: File, event: Event): void;
+    protected size(file: File): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptFileUpload, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptFileUpload, "kpt-file-upload", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Wybór koloru (swatch + hex + presety) na Signal Forms. Wartość = hex, np. '#3b82f6'.
+ *
+ * @example
+ * <kpt-color-picker [formField]="f.brand" />
+ */
+declare class KptColorPicker implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly presets: _angular_core.InputSignal<string[]>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected onHex(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptColorPicker, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptColorPicker, "kpt-color-picker", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+interface KptDateRangeValue {
+    start: string;
+    end: string;
+}
+interface DayCell {
+    day: number;
+    iso: string;
+    inMonth: boolean;
+    isStart: boolean;
+    isEnd: boolean;
+    inRange: boolean;
+    disabled: boolean;
+}
+/**
+ * Wybór zakresu dat z kalendarzem (CDK Overlay), Signal Forms.
+ * Wartość: `{ start: 'RRRR-MM-DD', end: 'RRRR-MM-DD' }`.
+ * Wymaga `import '@angular/cdk/overlay-prebuilt.css';`
+ *
+ * @example
+ * <kpt-date-range [formField]="f.period" />
+ */
+declare class KptDateRange implements FormValueControl<KptDateRangeValue> {
+    readonly value: _angular_core.ModelSignal<KptDateRangeValue>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    protected readonly weekdays: string[];
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    private readonly today;
+    private readonly view;
+    protected readonly positions: ConnectedPosition[];
+    protected readonly monthLabel: _angular_core.Signal<string>;
+    protected readonly display: _angular_core.Signal<string>;
+    protected readonly weeks: _angular_core.Signal<DayCell[][]>;
+    protected toggleOpen(): void;
+    protected close(): void;
+    protected selectDay(cell: DayCell): void;
+    protected prevMonth(): void;
+    protected nextMonth(): void;
+    protected clear(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDateRange, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDateRange, "kpt-date-range", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pole liczbowe ze strzałkami krokowania na Signal Forms. Wartość = number | null.
+ *
+ * @example
+ * <kpt-input-number [formField]="f.qty" [min]="0" [max]="99" [step]="1" />
+ */
+declare class KptInputNumber implements FormValueControl<number | null> {
+    readonly value: _angular_core.ModelSignal<number | null>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly suffix: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly display: _angular_core.Signal<string>;
+    protected readonly canInc: _angular_core.Signal<boolean>;
+    protected readonly canDec: _angular_core.Signal<boolean>;
+    protected onInput(event: Event): void;
+    protected step_(dir: 1 | -1): void;
+    private clamp;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptInputNumber, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptInputNumber, "kpt-input-number", never, { "value": { "alias": "value"; "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; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+interface Strength {
+    score: 0 | 1 | 2 | 3 | 4;
+    label: string;
+}
+/**
+ * Pole hasła z przełącznikiem widoczności i opcjonalnym miernikiem siły. Signal Forms.
+ *
+ * @example
+ * <kpt-password [formField]="f.password" feedback />
+ */
+declare class KptPassword implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly feedback: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    protected readonly strength: _angular_core.Signal<Strength>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptPassword, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptPassword, "kpt-password", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "feedback": { "alias": "feedback"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pole kodu jednorazowego (OTP/PIN) — N osobnych pól, autofocus i wklejanie. Signal Forms.
+ * Wartość = string (sklejone znaki).
+ *
+ * @example
+ * <kpt-input-otp [formField]="f.code" [length]="6" integerOnly />
+ */
+declare class KptInputOtp implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly length: _angular_core.InputSignal<number>;
+    readonly integerOnly: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly slots: _angular_core.Signal<number[]>;
+    protected charAt(i: number): string;
+    protected onInput(i: number, event: Event): void;
+    protected onKeydown(i: number, event: KeyboardEvent): void;
+    protected onPaste(event: ClipboardEvent): void;
+    private setChar;
+    private focusSibling;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptInputOtp, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptInputOtp, "kpt-input-otp", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": false; "isSignal": true; }; "integerOnly": { "alias": "integerOnly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pole tagów — dodawanie Enter/przecinkiem, usuwanie Backspace/×. Signal Forms.
+ * Wartość = string[].
+ *
+ * @example
+ * <kpt-chips-input [formField]="f.tags" placeholder="Dodaj tag…" />
+ */
+declare class KptChipsInput implements FormValueControl<string[]> {
+    readonly value: _angular_core.ModelSignal<string[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly allowDuplicates: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected onKeydown(event: KeyboardEvent): void;
+    protected commit(el: HTMLInputElement): void;
+    protected removeAt(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptChipsInput, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptChipsInput, "kpt-chips-input", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pole z maską znakową na Signal Forms. Tokeny maski: `9`=cyfra, `a`=litera, `*`=alfanumeryczny.
+ * Pozostałe znaki maski to literały (np. spacje, nawiasy, myślniki).
+ *
+ * @example
+ * <kpt-input-mask [formField]="f.phone" mask="(999) 999-99-99" />
+ */
+declare class KptInputMask implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly mask: _angular_core.InputSignal<string>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected onInput(event: Event): void;
+    private applyMask;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptInputMask, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptInputMask, "kpt-input-mask", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "mask": { "alias": "mask"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Lista wyboru (listbox) na Signal Forms. Pojedynczy lub wielokrotny wybór, opcjonalny filtr.
+ * Wartość: `T` (single) lub `T[]` (multiple).
+ *
+ * @example
+ * <kpt-listbox [formField]="f.role" [options]="roles" filter />
+ * <kpt-listbox [(value)]="tags" [options]="tagOptions" multiple />
+ */
+declare class KptListbox<T = unknown> implements FormValueControl<T | T[] | null> {
+    readonly value: _angular_core.ModelSignal<T | T[] | null>;
+    readonly options: _angular_core.InputSignal<KptOption<T>[]>;
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly filter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly visible: _angular_core.Signal<KptOption<T>[]>;
+    protected isSelected(v: T): boolean;
+    protected toggle(v: T): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptListbox<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptListbox<any>, "kpt-listbox", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "filter": { "alias": "filter"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+/**
+ * Pokrętło (knob) — wybór wartości po łuku, myszką lub strzałkami. Signal Forms.
+ *
+ * @example
+ * <kpt-knob [formField]="f.level" [min]="0" [max]="100" [step]="1" />
+ */
+declare class KptKnob implements FormValueControl<number> {
+    private readonly host;
+    readonly value: _angular_core.ModelSignal<number>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly step: _angular_core.InputSignal<number>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly stroke: _angular_core.InputSignal<number>;
+    readonly suffix: _angular_core.InputSignal<string>;
+    readonly showValue: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    private readonly startAngle;
+    private readonly sweep;
+    protected readonly rangePath: _angular_core.Signal<string>;
+    protected readonly valuePath: _angular_core.Signal<string>;
+    private ratio;
+    private arc;
+    protected onPointer(event: PointerEvent): void;
+    private setFromPoint;
+    private applyRatio;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptKnob, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptKnob, "kpt-knob", never, { "value": { "alias": "value"; "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; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "stroke": { "alias": "stroke"; "required": false; "isSignal": true; }; "suffix": { "alias": "suffix"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+type KptCardVariant = 'elevated' | 'outlined';
+/**
+ * Karta Koncept UI — powierzchnia z wyniesieniem (elevated) lub obramowaniem (outlined).
+ * Opcjonalny nagłówek przez `header`; treść przez projekcję. Stopkę wstaw z atrybutem
+ * `kptCardFooter`.
+ *
+ * @example
+ * <kpt-card header="Ustawienia">
+ *   <p>Treść karty…</p>
+ *   <div kptCardFooter><kpt-button>Zapisz</kpt-button></div>
+ * </kpt-card>
+ */
+declare class KptCard {
+    /** Wariant wizualny. */
+    readonly variant: _angular_core.InputSignal<KptCardVariant>;
+    /** Opcjonalny tekst nagłówka. */
+    readonly header: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptCard, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptCard, "kpt-card", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; }, {}, never, ["*", "[kptCardFooter]"], true, never>;
+}
+
+type KptDividerOrientation = 'horizontal' | 'vertical';
+/**
+ * Separator Koncept UI (linia pozioma lub pionowa). Kolor z `--kpt-color-border`.
+ *
+ * @example
+ * <kpt-divider />
+ * <kpt-divider orientation="vertical" />
+ * <kpt-divider inset />
+ */
+declare class KptDivider {
+    /** Orientacja linii. */
+    readonly orientation: _angular_core.InputSignal<KptDividerOrientation>;
+    /** Wcięcie (odstęp od krawędzi kontenera). */
+    readonly inset: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDivider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDivider, "kpt-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Górny pasek (toolbar) — pozioma belka na treść aplikacji (logo, akcje).
+ * Elementowi z atrybutem `kptToolbarSpacer` nadaj elastyczny odstęp, aby rozepchnąć zawartość.
+ *
+ * @example
+ * <kpt-toolbar elevated>
+ *   <strong>Koncept UI</strong>
+ *   <span kptToolbarSpacer></span>
+ *   <kpt-button variant="text">Wyloguj</kpt-button>
+ * </kpt-toolbar>
+ */
+declare class KptToolbar {
+    /** Dodaje cień (wyniesienie) pod paskiem. */
+    readonly elevated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptToolbar, "kpt-toolbar", never, { "elevated": { "alias": "elevated"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Panel boczny (sidenav) — stylowany kontener nawigacji, zwykle umieszczany w slocie
+ * `kptShellSidenav` komponentu `kpt-app-shell`.
+ *
+ * @example
+ * <kpt-sidenav kptShellSidenav>
+ *   <a href="#">Pulpit</a>
+ *   <a href="#">Ustawienia</a>
+ * </kpt-sidenav>
+ */
+declare class KptSidenav {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSidenav, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSidenav, "kpt-sidenav", never, {}, {}, never, ["*"], true, never>;
+}
+
+type KptSidenavMode = 'side' | 'over';
+/**
+ * Szkielet aplikacji (app shell) w stylu Material: toolbar u góry, panel boczny i treść.
+ * Sloty projekcji: `[kptShellToolbar]`, `[kptShellSidenav]`, oraz treść domyślna.
+ *
+ * @example
+ * <kpt-app-shell [(sidenavOpen)]="navOpen" sidenavMode="side">
+ *   <kpt-toolbar kptShellToolbar>…</kpt-toolbar>
+ *   <kpt-sidenav kptShellSidenav>…</kpt-sidenav>
+ *   <router-outlet />
+ * </kpt-app-shell>
+ */
+declare class KptAppShell {
+    /** Czy panel boczny jest otwarty (dwukierunkowe). */
+    readonly sidenavOpen: _angular_core.ModelSignal<boolean>;
+    /** Tryb panelu: 'side' rozpycha treść, 'over' nakłada się ze scrimem. */
+    readonly sidenavMode: _angular_core.InputSignal<KptSidenavMode>;
+    protected onScrimClick(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAppShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAppShell, "kpt-app-shell", never, { "sidenavOpen": { "alias": "sidenavOpen"; "required": false; "isSignal": true; }; "sidenavMode": { "alias": "sidenavMode"; "required": false; "isSignal": true; }; }, { "sidenavOpen": "sidenavOpenChange"; }, never, ["[kptShellToolbar]", "[kptShellSidenav]", "*"], true, never>;
+}
+
+/**
+ * Panel z nagłówkiem i opcjonalnym zwijaniem. Akcje nagłówka: atrybut `kptPanelActions`.
+ *
+ * @example
+ * <kpt-panel header="Ustawienia" toggleable>Treść…</kpt-panel>
+ */
+declare class KptPanel {
+    readonly header: _angular_core.InputSignal<string>;
+    readonly toggleable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsed: _angular_core.ModelSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptPanel, "kpt-panel", never, { "header": { "alias": "header"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["[kptPanelActions]", "*"], true, never>;
+}
+
+/**
+ * Grupa pól z legendą (fieldset), opcjonalnie zwijana.
+ *
+ * @example
+ * <kpt-fieldset legend="Dane osobowe" toggleable>…</kpt-fieldset>
+ */
+declare class KptFieldset {
+    readonly legend: _angular_core.InputSignal<string>;
+    readonly toggleable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapsed: _angular_core.ModelSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptFieldset, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptFieldset, "kpt-fieldset", never, { "legend": { "alias": "legend"; "required": false; "isSignal": true; }; "toggleable": { "alias": "toggleable"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+type KptSplitterOrientation = 'horizontal' | 'vertical';
+/**
+ * Splitter — dwa panele z przeciąganym uchwytem. Panele przez sloty `[kptSplitStart]` i `[kptSplitEnd]`.
+ * `horizontal` = panele obok siebie, `vertical` = jeden pod drugim.
+ *
+ * @example
+ * <kpt-splitter orientation="horizontal" [(startSize)]="size">
+ *   <div kptSplitStart>Lewy</div>
+ *   <div kptSplitEnd>Prawy</div>
+ * </kpt-splitter>
+ */
+declare class KptSplitter {
+    private readonly host;
+    readonly orientation: _angular_core.InputSignal<KptSplitterOrientation>;
+    /** Rozmiar pierwszego panelu w procentach (0–100). */
+    readonly startSize: _angular_core.ModelSignal<number>;
+    readonly minSize: _angular_core.InputSignal<number>;
+    protected readonly endSize: _angular_core.Signal<number>;
+    protected onPointer(event: PointerEvent): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private setSize;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSplitter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSplitter, "kpt-splitter", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "startSize": { "alias": "startSize"; "required": false; "isSignal": true; }; "minSize": { "alias": "minSize"; "required": false; "isSignal": true; }; }, { "startSize": "startSizeChange"; }, never, ["[kptSplitStart]", "[kptSplitEnd]"], true, never>;
+}
+
+/**
+ * Przycisk „do góry" — pojawia się po przewinięciu ponad `threshold` px.
+ * Domyślnie działa na oknie; `target` przyjmuje selektor przewijanego elementu.
+ *
+ * @example
+ * <kpt-scroll-top [threshold]="300" />
+ */
+declare class KptScrollTop {
+    readonly threshold: _angular_core.InputSignal<number>;
+    readonly target: _angular_core.InputSignal<string | null>;
+    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    private scroller;
+    constructor();
+    private currentTop;
+    protected scrollUp(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptScrollTop, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptScrollTop, "kpt-scroll-top", never, { "threshold": { "alias": "threshold"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Obraz z opcjonalnym podglądem pełnoekranowym (zoom).
+ *
+ * @example
+ * <kpt-image src="/foto.jpg" alt="Zdjęcie" preview width="240px" />
+ */
+declare class KptImage {
+    readonly src: _angular_core.InputSignal<string>;
+    readonly alt: _angular_core.InputSignal<string>;
+    readonly width: _angular_core.InputSignal<string | null>;
+    readonly preview: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected openPreview(): void;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptImage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptImage, "kpt-image", never, { "src": { "alias": "src"; "required": true; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "preview": { "alias": "preview"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface KptMeterItem {
+    label: string;
+    value: number;
+    color?: string;
+}
+/**
+ * Wielosegmentowy miernik (meter group) z opcjonalną legendą.
+ *
+ * @example
+ * <kpt-meter-group [values]="[{label:'Użyte', value:70}, {label:'Wolne', value:30}]" />
+ */
+declare class KptMeterGroup {
+    readonly values: _angular_core.InputSignal<KptMeterItem[]>;
+    /** Suma odniesienia; domyślnie suma wartości (100%). */
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly showLegend: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly palette;
+    protected readonly sum: _angular_core.Signal<number>;
+    protected total(): number;
+    protected percent(item: KptMeterItem): number;
+    protected fallback(i: number): string;
+    protected round(n: number): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMeterGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMeterGroup, "kpt-meter-group", never, { "values": { "alias": "values"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "showLegend": { "alias": "showLegend"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface KptAvatarItem {
+    name?: string;
+    src?: string;
+    icon?: string;
+}
+/**
+ * Grupa nakładających się awatarów z licznikiem „+N". Buduje na `kpt-avatar`.
+ *
+ * @example
+ * <kpt-avatar-group [avatars]="team" [max]="4" />
+ */
+declare class KptAvatarGroup {
+    readonly avatars: _angular_core.InputSignal<KptAvatarItem[]>;
+    readonly max: _angular_core.InputSignal<number>;
+    readonly size: _angular_core.InputSignal<KptAvatarSize>;
+    protected readonly shown: _angular_core.Signal<KptAvatarItem[]>;
+    protected readonly overflow: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAvatarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAvatarGroup, "kpt-avatar-group", never, { "avatars": { "alias": "avatars"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Stan pusty (empty state) — ikona, tytuł, opis i opcjonalne akcje (projekcja).
+ *
+ * @example
+ * <kpt-empty icon="search" title="Brak wyników" description="Zmień kryteria wyszukiwania.">
+ *   <kpt-button>Wyczyść filtry</kpt-button>
+ * </kpt-empty>
+ */
+declare class KptEmpty {
+    readonly icon: _angular_core.InputSignal<string | null>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly description: _angular_core.InputSignal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptEmpty, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptEmpty, "kpt-empty", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Pojedyncza zakładka. Umieszczaj w `kpt-tabs`. Treść renderowana leniwie (gdy aktywna).
+ *
+ * @example
+ * <kpt-tab label="Ogólne">…treść…</kpt-tab>
+ */
+declare class KptTab {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly content: _angular_core.Signal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptTab, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptTab, "kpt-tab", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Zakładki (tabs) — przełączanie widoków. Treść zakładek renderowana leniwie.
+ *
+ * @example
+ * <kpt-tabs [(activeIndex)]="tab">
+ *   <kpt-tab label="Ogólne">…</kpt-tab>
+ *   <kpt-tab label="Zaawansowane">…</kpt-tab>
+ * </kpt-tabs>
+ */
+declare class KptTabs {
+    protected readonly tabs: _angular_core.Signal<readonly KptTab[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    protected readonly activeTab: _angular_core.Signal<KptTab>;
+    protected select(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptTabs, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptTabs, "kpt-tabs", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["tabs"], never, true, never>;
+}
+
+/**
+ * Panel akordeonu. Umieszczaj w `kpt-accordion`. Stan `expanded` jest dwukierunkowy.
+ */
+declare class KptAccordionPanel {
+    readonly title: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly expanded: _angular_core.ModelSignal<boolean>;
+    private readonly accordion;
+    protected toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAccordionPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAccordionPanel, "kpt-accordion-panel", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Akordeon — grupa rozwijanych paneli. `multi` pozwala otworzyć wiele naraz.
+ *
+ * @example
+ * <kpt-accordion>
+ *   <kpt-accordion-panel title="Sekcja 1">…</kpt-accordion-panel>
+ *   <kpt-accordion-panel title="Sekcja 2">…</kpt-accordion-panel>
+ * </kpt-accordion>
+ */
+declare class KptAccordion {
+    readonly multi: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly panels;
+    /** Wywoływane przez panel przy otwarciu — zamyka pozostałe, gdy nie `multi`. */
+    onOpen(opened: KptAccordionPanel): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAccordion, "kpt-accordion", never, { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; }, {}, ["panels"], ["*"], true, never>;
+}
+
+interface KptBreadcrumbItem {
+    label: string;
+    url?: string;
+}
+/**
+ * Ścieżka nawigacji (breadcrumbs).
+ *
+ * @example
+ * <kpt-breadcrumb [items]="[{label:'Start',url:'/'},{label:'Ustawienia'}]" />
+ */
+declare class KptBreadcrumb {
+    readonly items: _angular_core.InputSignal<KptBreadcrumbItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptBreadcrumb, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptBreadcrumb, "kpt-breadcrumb", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Krok w `kpt-stepper`. Treść renderowana leniwie (gdy krok aktywny).
+ *
+ * @example
+ * <kpt-step label="Konto">…</kpt-step>
+ */
+declare class KptStep {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly content: _angular_core.Signal<TemplateRef<any>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptStep, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptStep, "kpt-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * Kreator kroków (stepper). Nagłówek z numerowanymi krokami + aktywna treść.
+ * Metody `next()`/`prev()`/`goTo()` do sterowania (np. z przycisków).
+ *
+ * @example
+ * <kpt-stepper #s [(activeIndex)]="step">
+ *   <kpt-step label="Konto">…<kpt-button (click)="s.next()">Dalej</kpt-button></kpt-step>
+ *   <kpt-step label="Profil">…</kpt-step>
+ * </kpt-stepper>
+ */
+declare class KptStepper {
+    protected readonly steps: _angular_core.Signal<readonly KptStep[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    protected readonly activeStep: _angular_core.Signal<KptStep>;
+    goTo(index: number): void;
+    next(): void;
+    prev(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptStepper, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptStepper, "kpt-stepper", never, { "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["steps"], never, true, never>;
+}
+
+/**
+ * Paginator Koncept UI. Sterowany sygnałami; `pageIndex` i `pageSize` są dwukierunkowe.
+ *
+ * @example
+ * <kpt-paginator [length]="total()" [(pageIndex)]="page" [(pageSize)]="size" />
+ */
+declare class KptPaginator {
+    /** Łączna liczba elementów. */
+    readonly length: _angular_core.InputSignal<number>;
+    /** Rozmiar strony (dwukierunkowe). */
+    readonly pageSize: _angular_core.ModelSignal<number>;
+    /** Indeks strony od 0 (dwukierunkowe). */
+    readonly pageIndex: _angular_core.ModelSignal<number>;
+    /** Dostępne rozmiary strony. */
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    readonly totalPages: _angular_core.Signal<number>;
+    readonly rangeStart: _angular_core.Signal<number>;
+    readonly rangeEnd: _angular_core.Signal<number>;
+    readonly canPrev: _angular_core.Signal<boolean>;
+    readonly canNext: _angular_core.Signal<boolean>;
+    constructor();
+    prev(): void;
+    next(): void;
+    onSizeChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptPaginator, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptPaginator, "kpt-paginator", never, { "length": { "alias": "length"; "required": true; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; }, { "pageSize": "pageSizeChange"; "pageIndex": "pageIndexChange"; }, never, never, true, never>;
+}
+
+interface KptColumn {
+    /** Nazwa pola w wierszu. */
+    field: string;
+    /** Nagłówek kolumny. */
+    header: string;
+    /** Czy kolumna jest sortowalna. */
+    sortable?: boolean;
+    /** Wyrównanie zawartości. */
+    align?: 'start' | 'center' | 'end';
+    /** Szerokość kolumny (np. '10rem', '20%'). Wymagane dla kolumn zamrożonych. */
+    width?: string;
+    /** Zamrożenie (sticky) — obsługiwane dla wiodących, sąsiadujących kolumn. */
+    frozen?: boolean;
+}
+type SortDir = 'asc' | 'desc' | null;
+/** Stan przekazywany w trybie lazy przy każdej zmianie sortowania/filtra/strony. */
+interface KptTableLazyState {
+    pageIndex: number;
+    pageSize: number;
+    sortField: string | null;
+    sortDir: SortDir;
+    filter: string;
+}
+/**
+ * Flagowa tabela danych Koncept UI (w duchu PrimeNG): kolumny konfiguracją, sortowanie,
+ * filtr globalny, paginacja, zaznaczanie wierszy i własne szablony komórek (`kptCell`).
+ * Sygnałowa, OnPush. Stylowanie tokenami `--kpt-table-*`.
+ *
+ * @example
+ * <kpt-data-table [columns]="cols" [data]="rows" filterable [pageSize]="10"
+ *                 selectable="multiple" rowKey="id" [(selection)]="picked">
+ *   <ng-template kptCell="status" let-value="value">
+ *     <span class="badge">{{ value }}</span>
+ *   </ng-template>
+ * </kpt-data-table>
+ */
+declare class KptDataTable<T = Record<string, unknown>> {
+    readonly columns: _angular_core.InputSignal<readonly KptColumn[]>;
+    readonly data: _angular_core.InputSignal<readonly T[]>;
+    readonly filterable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Rozmiar strony; 0 wyłącza paginację. */
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
+    readonly selectable: _angular_core.InputSignal<"none" | "single" | "multiple">;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    /** Pole identyfikujące wiersz (dla zaznaczania). Bez niego — porównanie po referencji. */
+    readonly rowKey: _angular_core.InputSignal<string | null>;
+    /** Wysokość przewijalnego obszaru (np. '400px'); sticky header pozostaje widoczny. */
+    readonly scrollHeight: _angular_core.InputSignal<string | null>;
+    /** Wirtualizacja wierszy dla dużych zbiorów (renderuje tylko widoczne). Wymaga `scrollHeight`. */
+    readonly virtualScroll: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Wysokość wiersza w px (stała, wymagana przy virtualScroll). */
+    readonly rowHeight: _angular_core.InputSignal<number>;
+    /** Umożliwia przestawianie kolumn metodą przeciągnij-i-upuść. */
+    readonly reorderable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Pokazuje przycisk eksportu do CSV. */
+    readonly exportable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Nazwa pliku eksportu CSV. */
+    readonly exportFilename: _angular_core.InputSignal<string>;
+    /** Tryb serwerowy: bez filtrowania/sortowania/paginacji po stronie klienta. */
+    readonly lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Łączna liczba rekordów (wymagane w trybie lazy dla paginacji). */
+    readonly totalRecords: _angular_core.InputSignal<number | null>;
+    readonly selection: _angular_core.ModelSignal<T[]>;
+    readonly rowClick: _angular_core.OutputEmitterRef<T>;
+    /** Emitowane w trybie lazy przy zmianie sortowania/filtra/strony. */
+    readonly lazyLoad: _angular_core.OutputEmitterRef<KptTableLazyState>;
+    /** Kolumny w bieżącej kolejności (po ewentualnym przestawieniu). */
+    protected readonly orderedColumns: _angular_core.WritableSignal<readonly KptColumn[]>;
+    private readonly scrollEl;
+    protected readonly scrollTop: _angular_core.WritableSignal<number>;
+    protected readonly viewportHeight: _angular_core.WritableSignal<number>;
+    private readonly buffer;
+    constructor();
+    protected onScroll(event: Event): void;
+    protected readonly virtualStart: _angular_core.Signal<number>;
+    protected readonly virtualEnd: _angular_core.Signal<number>;
+    protected readonly virtualRows: _angular_core.Signal<T[]>;
+    protected readonly topPad: _angular_core.Signal<number>;
+    protected readonly bottomPad: _angular_core.Signal<number>;
+    protected readonly dragIndex: _angular_core.WritableSignal<number | null>;
+    protected onColDragStart(index: number, event: DragEvent): void;
+    protected onColDragOver(event: DragEvent): void;
+    protected onColDrop(index: number, event: DragEvent): void;
+    protected onColDragEnd(): void;
+    exportCsv(): void;
+    private readonly cellDefs;
+    private readonly cellMap;
+    protected cellTemplate(field: string): TemplateRef<unknown> | null;
+    protected readonly filterText: _angular_core.WritableSignal<string>;
+    protected readonly sortField: _angular_core.WritableSignal<string | null>;
+    protected readonly sortDir: _angular_core.WritableSignal<SortDir>;
+    protected readonly pageIndex: _angular_core.WritableSignal<number>;
+    protected readonly pageSizeState: _angular_core.WritableSignal<number>;
+    private readonly filtered;
+    private readonly sorted;
+    protected readonly filteredCount: _angular_core.Signal<number>;
+    protected readonly paged: _angular_core.Signal<readonly T[]>;
+    protected readonly colspan: _angular_core.Signal<number>;
+    protected readonly displayCount: _angular_core.Signal<number>;
+    private parseWidthPx;
+    /** Mapa pole → przesunięcie left (px) dla wiodących zamrożonych kolumn. */
+    private readonly frozenOffsets;
+    protected readonly hasFrozen: _angular_core.Signal<boolean>;
+    protected frozenLeft(field: string): number | null;
+    protected isFrozen(field: string): boolean;
+    protected toggleSort(col: KptColumn): void;
+    protected sortIconName(col: KptColumn): KptIconName;
+    protected ariaSort(col: KptColumn): 'ascending' | 'descending' | 'none';
+    protected onFilter(event: Event): void;
+    private sameRow;
+    protected isSelected(row: T): boolean;
+    protected toggleRow(row: T): void;
+    protected readonly pageAllSelected: _angular_core.Signal<boolean>;
+    protected toggleAllOnPage(): void;
+    protected onRowClick(row: T): void;
+    protected getValue(row: T, field: string): unknown;
+    protected trackRow: (row: T) => unknown;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDataTable<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDataTable<any>, "kpt-data-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "filterable": { "alias": "filterable"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "rowKey": { "alias": "rowKey"; "required": false; "isSignal": true; }; "scrollHeight": { "alias": "scrollHeight"; "required": false; "isSignal": true; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; "isSignal": true; }; "rowHeight": { "alias": "rowHeight"; "required": false; "isSignal": true; }; "reorderable": { "alias": "reorderable"; "required": false; "isSignal": true; }; "exportable": { "alias": "exportable"; "required": false; "isSignal": true; }; "exportFilename": { "alias": "exportFilename"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "totalRecords": { "alias": "totalRecords"; "required": false; "isSignal": true; }; "selection": { "alias": "selection"; "required": false; "isSignal": true; }; }, { "selection": "selectionChange"; "rowClick": "rowClick"; "lazyLoad": "lazyLoad"; }, ["cellDefs"], never, true, never>;
+}
+
+/**
+ * Własny szablon komórki dla kolumny `kpt-data-table`. Kontekst: `$implicit` = wiersz,
+ * `value` = wartość pola.
+ *
+ * @example
+ * <kpt-data-table [columns]="cols" [data]="rows">
+ *   <ng-template kptCell="status" let-row let-value="value">
+ *     <span class="badge">{{ value }}</span>
+ *   </ng-template>
+ * </kpt-data-table>
+ */
+declare class KptCellDef {
+    /** Nazwa pola kolumny, dla której obowiązuje szablon. */
+    readonly kptCell: _angular_core.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptCellDef, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KptCellDef, "ng-template[kptCell]", never, { "kptCell": { "alias": "kptCell"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface KptTreeNode<T = unknown> {
+    label: string;
+    value?: T;
+    icon?: string;
+    children?: KptTreeNode<T>[];
+    expanded?: boolean;
+    disabled?: boolean;
+}
+/**
+ * Drzewo hierarchiczne (rozwijanie, zaznaczanie, ikony). Dane przez `nodes`.
+ *
+ * @example
+ * <kpt-tree [nodes]="tree" selectable [(selected)]="node" (nodeClick)="open($event)" />
+ */
+declare class KptTree<T = unknown> {
+    readonly nodes: _angular_core.InputSignal<KptTreeNode<T>[]>;
+    readonly selectable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly selected: _angular_core.ModelSignal<KptTreeNode<T> | null>;
+    readonly nodeClick: _angular_core.OutputEmitterRef<KptTreeNode<T>>;
+    private readonly version;
+    protected has(node: KptTreeNode<T>): boolean;
+    protected isOpen(node: KptTreeNode<T>): boolean;
+    protected isSelected(node: KptTreeNode<T>): boolean;
+    protected toggle(node: KptTreeNode<T>, event: Event): void;
+    protected onRow(node: KptTreeNode<T>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptTree<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptTree<any>, "kpt-tree", never, { "nodes": { "alias": "nodes"; "required": false; "isSignal": true; }; "selectable": { "alias": "selectable"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; }, { "selected": "selectedChange"; "nodeClick": "nodeClick"; }, never, never, true, never>;
+}
+
+interface KptTimelineItem {
+    title: string;
+    description?: string;
+    time?: string;
+    icon?: string;
+    variant?: 'neutral' | 'primary' | 'success' | 'danger' | 'warning' | 'info';
+}
+/**
+ * Oś czasu (timeline) — pionowa lista zdarzeń z markerami.
+ *
+ * @example
+ * <kpt-timeline [items]="[{title:'Utworzono', time:'10:00', variant:'success', icon:'check'}]" />
+ */
+declare class KptTimeline {
+    readonly items: _angular_core.InputSignal<KptTimelineItem[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptTimeline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptTimeline, "kpt-timeline", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Karuzela slajdów. Dane przez `items`, szablon slajdu przez projekcję `<ng-template let-item>`.
+ *
+ * @example
+ * <kpt-carousel [items]="photos">
+ *   <ng-template let-photo><img [src]="photo" style="width:100%" /></ng-template>
+ * </kpt-carousel>
+ */
+declare class KptCarousel<T = unknown> {
+    readonly items: _angular_core.InputSignal<T[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    protected readonly slideTpl: _angular_core.Signal<TemplateRef<any>>;
+    next(): void;
+    prev(): void;
+    goTo(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptCarousel<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptCarousel<any>, "kpt-carousel", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, ["slideTpl"], never, true, never>;
+}
+
+/**
+ * DataView — prezentacja listy elementów w układzie lista/siatka, z opcjonalną paginacją.
+ * Szablon elementu przez projekcję `<ng-template let-item>`.
+ *
+ * @example
+ * <kpt-data-view [items]="products" [pageSize]="6">
+ *   <ng-template let-p><div>{{ p.name }}</div></ng-template>
+ * </kpt-data-view>
+ */
+declare class KptDataView<T = unknown> {
+    readonly items: _angular_core.InputSignal<T[]>;
+    readonly layout: _angular_core.ModelSignal<"list" | "grid">;
+    readonly pageSize: _angular_core.InputSignal<number>;
+    readonly paginated: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly itemTpl: _angular_core.Signal<TemplateRef<any>>;
+    protected readonly pageIndex: _angular_core.ModelSignal<number>;
+    protected readonly showPager: _angular_core.Signal<boolean>;
+    protected readonly pageItems: _angular_core.Signal<T[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDataView<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDataView<any>, "kpt-data-view", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; "paginated": { "alias": "paginated"; "required": false; "isSignal": true; }; "pageIndex": { "alias": "pageIndex"; "required": false; "isSignal": true; }; }, { "layout": "layoutChange"; "pageIndex": "pageIndexChange"; }, ["itemTpl"], never, true, never>;
+}
+
+/**
+ * PickList — transfer elementów między dwiema listami (źródło ↔ cel).
+ * Szablon elementu przez projekcję `<ng-template let-item>`.
+ *
+ * @example
+ * <kpt-pick-list [(source)]="available" [(target)]="selected" sourceHeader="Dostępne" targetHeader="Wybrane">
+ *   <ng-template let-item>{{ item.name }}</ng-template>
+ * </kpt-pick-list>
+ */
+declare class KptPickList<T = unknown> {
+    readonly source: _angular_core.ModelSignal<T[]>;
+    readonly target: _angular_core.ModelSignal<T[]>;
+    readonly sourceHeader: _angular_core.InputSignal<string>;
+    readonly targetHeader: _angular_core.InputSignal<string>;
+    protected readonly itemTpl: _angular_core.Signal<TemplateRef<any>>;
+    protected readonly selSource: _angular_core.WritableSignal<Set<T>>;
+    protected readonly selTarget: _angular_core.WritableSignal<Set<T>>;
+    protected toggle(side: 'source' | 'target', item: T): void;
+    protected move(from: 'source' | 'target', all: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptPickList<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptPickList<any>, "kpt-pick-list", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "target": { "alias": "target"; "required": false; "isSignal": true; }; "sourceHeader": { "alias": "sourceHeader"; "required": false; "isSignal": true; }; "targetHeader": { "alias": "targetHeader"; "required": false; "isSignal": true; }; }, { "source": "sourceChange"; "target": "targetChange"; }, ["itemTpl"], never, true, never>;
+}
+
+/**
+ * OrderList — lista z ręcznym porządkowaniem elementów (w górę/dół).
+ * Szablon elementu przez projekcję `<ng-template let-item>`.
+ *
+ * @example
+ * <kpt-order-list [(items)]="tasks" header="Kolejność">
+ *   <ng-template let-item>{{ item.name }}</ng-template>
+ * </kpt-order-list>
+ */
+declare class KptOrderList<T = unknown> {
+    readonly items: _angular_core.ModelSignal<T[]>;
+    readonly header: _angular_core.InputSignal<string>;
+    protected readonly itemTpl: _angular_core.Signal<TemplateRef<any>>;
+    protected readonly selected: _angular_core.WritableSignal<number | null>;
+    protected moveSelected(dir: -1 | 1): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptOrderList<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptOrderList<any>, "kpt-order-list", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; }, { "items": "itemsChange"; }, ["itemTpl"], never, true, never>;
+}
+
+interface KptGalleriaItem {
+    src: string;
+    thumbnail?: string;
+    alt?: string;
+}
+/**
+ * Galleria — duży podgląd obrazu z paskiem miniatur i nawigacją.
+ *
+ * @example
+ * <kpt-galleria [items]="photos" [(activeIndex)]="idx" />
+ */
+declare class KptGalleria {
+    readonly items: _angular_core.InputSignal<KptGalleriaItem[]>;
+    readonly activeIndex: _angular_core.ModelSignal<number>;
+    readonly showThumbnails: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly current: _angular_core.Signal<KptGalleriaItem>;
+    protected next(): void;
+    protected prev(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptGalleria, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptGalleria, "kpt-galleria", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; "showThumbnails": { "alias": "showThumbnails"; "required": false; "isSignal": true; }; }, { "activeIndex": "activeIndexChange"; }, never, never, true, never>;
+}
+
+type KptAlertVariant = 'info' | 'success' | 'warning' | 'danger';
+/**
+ * Komunikat inline (alert). Warianty info/success/warning/danger, opcjonalny tytuł i zamykanie.
+ *
+ * @example
+ * <kpt-alert variant="success" title="Zapisano">Zmiany zostały zapisane.</kpt-alert>
+ */
+declare class KptAlert {
+    readonly variant: _angular_core.InputSignal<KptAlertVariant>;
+    readonly title: _angular_core.InputSignal<string>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    protected readonly visible: _angular_core.WritableSignal<boolean>;
+    protected iconName(): KptIconName;
+    protected dismiss(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAlert, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAlert, "kpt-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "closed": "closed"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Okno modalne na natywnym `<dialog>` (focus trap, ESC, backdrop w standardzie).
+ * Sterowane sygnałem `open` (dwukierunkowe). Stopkę wstaw z atrybutem `kptDialogFooter`.
+ *
+ * @example
+ * <kpt-dialog [(open)]="confirmOpen" header="Usunąć?">
+ *   Tej operacji nie można cofnąć.
+ *   <div kptDialogFooter>
+ *     <kpt-button variant="text" (click)="confirmOpen.set(false)">Anuluj</kpt-button>
+ *     <kpt-button variant="danger" (click)="remove()">Usuń</kpt-button>
+ *   </div>
+ * </kpt-dialog>
+ */
+declare class KptDialog {
+    /** Otwarcie okna (dwukierunkowe). */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly header: _angular_core.InputSignal<string>;
+    /** Pozwala zamknąć klawiszem Esc / przyciskiem ×. */
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    private readonly dialogRef;
+    constructor();
+    protected onCancel(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDialog, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDialog, "kpt-dialog", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*", "[kptDialogFooter]"], true, never>;
+}
+
+interface KptToast {
+    id: number;
+    message: string;
+    title?: string;
+    variant: KptAlertVariant;
+    /** Czas życia w ms; 0 = bez auto-zamykania. */
+    duration: number;
+}
+type KptToastOptions = Partial<Omit<KptToast, 'id' | 'message'>>;
+/**
+ * Serwis powiadomień (toastów). Wstrzyknij i wywołuj `show`/`success`/`error`/...;
+ * umieść `<kpt-toast-container />` raz w aplikacji, aby je renderować.
+ */
+declare class KptToastService {
+    private readonly _toasts;
+    readonly toasts: _angular_core.Signal<KptToast[]>;
+    private seq;
+    show(message: string, options?: KptToastOptions): number;
+    info(message: string, options?: KptToastOptions): number;
+    success(message: string, options?: KptToastOptions): number;
+    warning(message: string, options?: KptToastOptions): number;
+    error(message: string, options?: KptToastOptions): number;
+    dismiss(id: number): void;
+    clear(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptToastService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KptToastService>;
+}
+
+/**
+ * Kontener renderujący toasty z `KptToastService`. Umieść raz w aplikacji
+ * (np. w komponencie głównym): `<kpt-toast-container />`.
+ */
+declare class KptToastContainer {
+    private readonly service;
+    protected readonly toasts: _angular_core.Signal<_konce_pt_angular.KptToast[]>;
+    protected dismiss(id: number): void;
+    protected icon(variant: KptAlertVariant): KptIconName;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptToastContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptToastContainer, "kpt-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+type KptTooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+/**
+ * Dymek podpowiedzi (tooltip) pokazywany na hover/focus hosta. Lekki — element dodawany
+ * do `body` i pozycjonowany względem hosta (działa w trybie zoneless).
+ *
+ * @example
+ * <kpt-button kptTooltip="Zapisz zmiany" kptTooltipPosition="bottom">Zapisz</kpt-button>
+ */
+declare class KptTooltip implements OnDestroy {
+    readonly text: _angular_core.InputSignal<string>;
+    readonly position: _angular_core.InputSignal<KptTooltipPosition>;
+    private readonly host;
+    private tip?;
+    protected show(): void;
+    protected hide(): void;
+    private reposition;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptTooltip, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<KptTooltip, "[kptTooltip]", never, { "text": { "alias": "kptTooltip"; "required": true; "isSignal": true; }; "position": { "alias": "kptTooltipPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Popover — dowolna treść w dymku na CDK Overlay (bogatszy niż tooltip). Slot triggera:
+ * atrybut `kptPopoverTrigger`; reszta treści trafia do panelu.
+ * Wymaga stylów overlay CDK: `import '@angular/cdk/overlay-prebuilt.css';`
+ *
+ * @example
+ * <kpt-popover>
+ *   <kpt-button kptPopoverTrigger variant="outline">Szczegóły</kpt-button>
+ *   <div>Bogata treść popovera…</div>
+ * </kpt-popover>
+ */
+declare class KptPopover {
+    readonly placement: _angular_core.InputSignal<"bottom" | "top">;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly positions: ConnectedPosition[];
+    protected toggle(): void;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptPopover, "kpt-popover", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, {}, never, ["[kptPopoverTrigger]", "*"], true, never>;
+}
+
+/**
+ * Pole z podpowiedziami (autocomplete) na CDK Overlay, Signal Forms. Wartość = wpisany tekst.
+ * Wymaga stylów overlay CDK: `import '@angular/cdk/overlay-prebuilt.css';`
+ *
+ * @example
+ * <kpt-autocomplete [formField]="f.city" [options]="cities" placeholder="Miasto…" />
+ */
+declare class KptAutocomplete implements FormValueControl<string> {
+    readonly value: _angular_core.ModelSignal<string>;
+    readonly options: _angular_core.InputSignal<string[]>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touched: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly touch: _angular_core.OutputEmitterRef<void>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly activeIndex: _angular_core.WritableSignal<number>;
+    protected readonly positions: ConnectedPosition[];
+    protected readonly filtered: _angular_core.Signal<string[]>;
+    protected onInput(event: Event): void;
+    protected onFocus(): void;
+    protected onBlur(): void;
+    protected pick(opt: string): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptAutocomplete, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptAutocomplete, "kpt-autocomplete", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "touched": { "alias": "touched"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "touch": "touch"; }, never, never, true, never>;
+}
+
+type KptDrawerPosition = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * Panel wysuwany (drawer / off-canvas) sterowany sygnałem `open`. Niezależny od app-shell.
+ *
+ * @example
+ * <kpt-drawer [(open)]="menuOpen" position="right" header="Filtry">
+ *   Treść panelu…
+ * </kpt-drawer>
+ */
+declare class KptDrawer {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly position: _angular_core.InputSignal<KptDrawerPosition>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly dismissible: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly closeOnBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected onBackdrop(): void;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptDrawer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptDrawer, "kpt-drawer", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Menu kontekstowe (PPM) na obszarze projekcji. Panel pozycjonowany do kursora.
+ *
+ * @example
+ * <kpt-context-menu [items]="items" (select)="onSelect($event)">
+ *   <div class="obszar">Kliknij prawym przyciskiem</div>
+ * </kpt-context-menu>
+ */
+declare class KptContextMenu<T = unknown> {
+    readonly items: _angular_core.InputSignal<KptMenuItem<T>[]>;
+    readonly select: _angular_core.OutputEmitterRef<KptMenuItem<T>>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected readonly x: _angular_core.WritableSignal<number>;
+    protected readonly y: _angular_core.WritableSignal<number>;
+    protected onContext(event: MouseEvent): void;
+    protected close(): void;
+    protected pick(item: KptMenuItem<T>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptContextMenu<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptContextMenu<any>, "kpt-context-menu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Pozioma belka menu z rozwijanymi pod-menu. Pozycje bez `items` działają jak akcje/linki.
+ *
+ * @example
+ * <kpt-menubar [items]="items" (select)="onSelect($event)" />
+ */
+declare class KptMenubar<T = unknown> {
+    readonly items: _angular_core.InputSignal<KptMenuItem<T>[]>;
+    readonly select: _angular_core.OutputEmitterRef<KptMenuItem<T>>;
+    protected readonly openIndex: _angular_core.WritableSignal<number | null>;
+    protected toggle(i: number, item: KptMenuItem<T>): void;
+    protected pick(item: KptMenuItem<T>): void;
+    protected closeAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMenubar<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMenubar<any>, "kpt-menubar", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+/**
+ * Mega-menu — pozioma belka z szerokim, wielokolumnowym panelem.
+ * Struktura: pozycja górna → `items` (kolumny) → każda kolumna `items` (odnośniki).
+ *
+ * @example
+ * <kpt-megamenu [items]="items" (select)="onSelect($event)" />
+ */
+declare class KptMegamenu<T = unknown> {
+    readonly items: _angular_core.InputSignal<KptMenuItem<T>[]>;
+    readonly select: _angular_core.OutputEmitterRef<KptMenuItem<T>>;
+    protected readonly openIndex: _angular_core.WritableSignal<number | null>;
+    protected activeColumns(): KptMenuItem<T>[];
+    protected toggle(i: number): void;
+    protected pick(link: KptMenuItem<T>): void;
+    protected closeAll(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptMegamenu<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptMegamenu<any>, "kpt-megamenu", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+interface KptConfirmOptions {
+    message: string;
+    header?: string;
+    acceptLabel?: string;
+    rejectLabel?: string;
+    /** Wariant przycisku akceptacji. */
+    variant?: 'filled' | 'danger';
+    icon?: string;
+}
+interface KptConfirmRequest extends KptConfirmOptions {
+    id: number;
+    resolve: (accepted: boolean) => void;
+}
+/**
+ * Serwis potwierdzeń. Wstrzyknij i wywołaj `confirm(...)` (zwraca Promise<boolean>);
+ * umieść `<kpt-confirm-container />` raz w aplikacji.
+ *
+ * @example
+ * if (await confirm.confirm({ message: 'Usunąć rekord?', variant: 'danger' })) { ... }
+ */
+declare class KptConfirmService {
+    private readonly _current;
+    readonly current: _angular_core.Signal<KptConfirmRequest | null>;
+    private seq;
+    confirm(options: KptConfirmOptions): Promise<boolean>;
+    accept(): void;
+    reject(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptConfirmService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<KptConfirmService>;
+}
+
+/**
+ * Kontener potwierdzeń — renderuje aktywne żądanie z `KptConfirmService` na `kpt-dialog`.
+ * Umieść raz w aplikacji (np. obok `<kpt-toast-container />`).
+ */
+declare class KptConfirmContainer {
+    protected readonly service: KptConfirmService;
+    protected readonly req: _angular_core.Signal<_konce_pt_angular.KptConfirmRequest | null>;
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected onOpenChange(open: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptConfirmContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptConfirmContainer, "kpt-confirm-container", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Arkusz wysuwany z dołu ekranu (bottom sheet). Sterowany sygnałem `open`.
+ *
+ * @example
+ * <kpt-bottom-sheet [(open)]="sheetOpen" header="Udostępnij">
+ *   Treść arkusza…
+ * </kpt-bottom-sheet>
+ */
+declare class KptBottomSheet {
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly header: _angular_core.InputSignal<string>;
+    readonly closeOnBackdrop: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected onBackdrop(): void;
+    protected close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptBottomSheet, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptBottomSheet, "kpt-bottom-sheet", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; }, { "open": "openChange"; }, never, ["*"], true, never>;
+}
+
+type KptSpeedDialDirection = 'up' | 'down' | 'left' | 'right';
+/**
+ * Speed dial — FAB rozwijający zestaw akcji. Buduje na `kpt-fab`.
+ *
+ * @example
+ * <kpt-speed-dial [items]="actions" direction="up" (select)="onAction($event)" />
+ */
+declare class KptSpeedDial<T = unknown> {
+    readonly items: _angular_core.InputSignal<KptMenuItem<T>[]>;
+    readonly direction: _angular_core.InputSignal<KptSpeedDialDirection>;
+    readonly icon: _angular_core.InputSignal<string>;
+    readonly ariaLabel: _angular_core.InputSignal<string>;
+    readonly select: _angular_core.OutputEmitterRef<KptMenuItem<T>>;
+    protected readonly open: _angular_core.WritableSignal<boolean>;
+    protected toggle(): void;
+    protected close(): void;
+    protected pick(item: KptMenuItem<T>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KptSpeedDial<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KptSpeedDial<any>, "kpt-speed-dial", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "select": "select"; }, never, never, true, never>;
+}
+
+export { KptAccordion, KptAccordionPanel, KptAlert, KptAppShell, KptAutocomplete, KptAvatar, KptAvatarGroup, KptBadge, KptBottomSheet, KptBreadcrumb, KptButton, KptButtonGroup, KptCard, KptCarousel, KptCellDef, KptCheckbox, KptChip, KptChipsInput, KptColorPicker, KptConfirmContainer, KptConfirmService, KptContextMenu, KptDataTable, KptDataView, KptDateRange, KptDatepicker, KptDialog, KptDivider, KptDrawer, KptEmpty, KptFab, KptFieldset, KptFileUpload, KptFormField, KptGalleria, KptIcon, KptIconButton, KptIconRegistry, KptImage, KptInput, KptInputMask, KptInputNumber, KptInputOtp, KptKnob, KptListbox, KptMegamenu, KptMenu, KptMenubar, KptMeterGroup, KptOrderList, KptPaginator, KptPanel, KptPassword, KptPickList, KptPopover, KptProgress, KptRadioGroup, KptRating, KptRichText, KptScrollTop, KptSelect, KptSidenav, KptSkeleton, KptSlider, KptSpeedDial, KptSpinner, KptSplitButton, KptSplitter, KptStep, KptStepper, KptSwitch, KptTab, KptTabs, KptTextarea, KptTimeline, KptToastContainer, KptToastService, KptToolbar, KptTooltip, KptTree };
+export type { KptAlertVariant, KptAvatarItem, KptAvatarShape, KptAvatarSize, KptBadgeVariant, KptBreadcrumbItem, KptButtonSize, KptButtonVariant, KptCardVariant, KptChipVariant, KptColumn, KptConfirmOptions, KptConfirmRequest, KptDateRangeValue, KptDividerOrientation, KptDrawerPosition, KptGalleriaItem, KptIconName, KptInputType, KptMenuItem, KptMeterItem, KptOption, KptProgressVariant, KptRichTool, KptSidenavMode, KptSkeletonVariant, KptSpeedDialDirection, KptSplitterOrientation, KptTableLazyState, KptTimelineItem, KptToast, KptToastOptions, KptTooltipPosition, KptTreeNode };