@underlayerdev/ui 0.0.1

package/types/underlayerdev-ui.d.ts

@@ -0,0 +1,1464 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, ElementRef, PipeTransform } from '@angular/core';
+import * as i1 from '@angular/cdk/accordion';
+import { CdkAccordionItem } from '@angular/cdk/accordion';
+import { FormValueControl, WithOptionalField, ValidationError, FormCheckboxControl } from '@angular/forms/signals';
+import Splide, { Options } from '@splidejs/splide';
+import { CurrencyPipe } from '@angular/common';
+
+/**
+ * AccordionItemComponent is a standalone Angular component that extends CdkAccordionItem.
+ * It represents an item within an accordion, providing configurable expansion behavior
+ * and accessibility features.
+ */
+declare class AccordionItemComponent {
+    cdkAccordionItem: CdkAccordionItem;
+    private readonly elementRef;
+    /**
+     * Stable ID for the content region, used for aria-controls linkage.
+     */
+    readonly contentId: string;
+    /**
+     * Stable ID for the trigger button, used for aria-labelledby linkage.
+     */
+    readonly triggerId: string;
+    onToggle(): void;
+    onKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "pe-accordion-item", never, {}, {}, never, ["[pe-accordion-icon]", "[pe-accordion-label]", "[pe-accordion-status]", "[pe-accordion-content]"], true, [{ directive: typeof i1.CdkAccordionItem; inputs: { "expanded": "expanded"; "disabled": "disabled"; }; outputs: { "closed": "closed"; "opened": "opened"; "destroyed": "destroyed"; "expandedChange": "expandedChange"; }; }]>;
+}
+/**
+ * AccordionComponent is a standalone Angular component that acts as a container
+ * for multiple AccordionItemComponents. It provides configuration options for
+ * multi-expansion behavior and manages the state of its child accordion items.
+ */
+declare class AccordionComponent implements AfterViewInit {
+    readonly showDivider: _angular_core.InputSignal<boolean>;
+    readonly multi: _angular_core.InputSignal<boolean>;
+    private readonly destroyRef;
+    private readonly accordionItems;
+    ngAfterViewInit(): void;
+    /**
+     * Sets up the single expansion logic to ensure only one item is expanded at a time
+     * when multi mode is disabled.
+     */
+    private setupSingleExpansionLogic;
+    /**
+     * Handles expansion changes and manages single-expansion behavior.
+     * @param changedItem - The accordion item that changed
+     * @param expanded - Whether the item is now expanded
+     * @param allItems - Array of all accordion items
+     */
+    private handleExpansionChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "pe-accordion", never, { "showDivider": { "alias": "showDivider"; "required": false; "isSignal": true; }; "multi": { "alias": "multi"; "required": false; "isSignal": true; }; }, {}, ["accordionItems"], ["*"], true, never>;
+}
+
+/**
+ * A code display component that shows code with automatic line numbering.
+ * Features a clean two-column layout following PE design guidelines.
+ *
+ * @example
+ * <pe-area-code
+ *   [content]="codeContent"
+ *   [showLineNumbers]="true"
+ * />
+ */
+declare class AreaCodeComponent {
+    readonly content: _angular_core.InputSignal<string>;
+    readonly showLineNumbers: _angular_core.InputSignal<boolean>;
+    readonly maxHeight: _angular_core.InputSignal<string | null>;
+    readonly lines: _angular_core.Signal<string[]>;
+    readonly lineCount: _angular_core.Signal<number>;
+    readonly lineNumbers: _angular_core.Signal<number[]>;
+    readonly codeId: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AreaCodeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AreaCodeComponent, "pe-area-code", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "showLineNumbers": { "alias": "showLineNumbers"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type UiSize = 'sm' | 'md' | 'lg' | 'xl';
+type UiCheckboxSize = 'default' | 'sm';
+type UiTheme = 'fill-purple' | 'fill-white' | 'fill-yellow' | 'fill-red' | 'transparent-purple' | 'transparent-white' | 'transparent-red' | 'transparent-black' | 'ghost-purple' | 'ghost-white' | 'ghost-red' | 'ghost-green' | 'outline-white' | 'outline-purple' | 'outline-red' | 'outline-green';
+
+type IconSize$1 = '5' | '6' | '7' | '8';
+/**
+ * A reusable avatar component that displays user images, initials, or icons.
+ * Supports multiple sizes and fallback options when an image is not available.
+ * @example
+ * <pe-avatar size="md" [src]="userImageUrl" [initials]="'JD'" />
+ */
+declare class AvatarComponent {
+    /** The size of the avatar */
+    size: _angular_core.InputSignal<UiSize>;
+    /** The image source URL */
+    src: _angular_core.InputSignal<string | undefined>;
+    /** Fallback initials to display when image is not available */
+    initials: _angular_core.InputSignal<string | undefined>;
+    /** Fallback icon to display when image and initials are not available */
+    icon: _angular_core.InputSignal<string | undefined>;
+    /** Alt text for the avatar image */
+    alt: _angular_core.InputSignal<string>;
+    /** Show a skeleton placeholder instead of content while loading. */
+    loading: _angular_core.InputSignal<boolean>;
+    /** Internal signal to track image loading errors */
+    protected readonly imageError: _angular_core.WritableSignal<boolean>;
+    /** Computed icon size based on avatar size */
+    readonly iconSize: _angular_core.Signal<IconSize$1>;
+    constructor();
+    /** Handles image loading errors */
+    protected handleImageError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "pe-avatar", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Icon size keys from design tokens (iconography.font.size). */
+type IconSize = '4' | '5' | '6' | '7' | '8' | '10' | '12' | '16' | '24' | '32';
+/** Icon weight keys from design tokens (iconography.font.weight). */
+type IconWeight = 'medium' | 'bold';
+/** Icon name / glyph key from design tokens (content['icon-glyph']). Valid values match token keys. */
+type IconName = string;
+declare class IconComponent {
+    size: _angular_core.InputSignal<IconSize>;
+    weight: _angular_core.InputSignal<IconWeight>;
+    icon: _angular_core.InputSignal<string>;
+    readonly hostClasses: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<IconComponent, "pe-icon", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "weight": { "alias": "weight"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface AvatarData {
+    src?: string;
+    initials?: string;
+    icon?: IconName;
+    alt?: string;
+}
+/**
+ * A reusable avatar group component that displays multiple avatars with overflow handling.
+ * Supports maximum visible count and shows a "+X" indicator for remaining avatars.
+ * @example
+ * <pe-avatar-group [avatars]="userAvatars" [maxVisible]="3" size="md" />
+ */
+declare class AvatarGroupComponent {
+    /** Array of avatar data to display */
+    avatars: _angular_core.InputSignal<AvatarData[]>;
+    /** The size of all avatars in the group */
+    size: _angular_core.InputSignal<UiSize>;
+    /** Maximum number of avatars to display before showing overflow indicator */
+    maxVisible: _angular_core.InputSignal<number | null>;
+    /** Whether avatars should overlap (stacked) or have spacing between them */
+    stacked: _angular_core.InputSignal<boolean>;
+    /** Computed list of visible avatars */
+    readonly visibleAvatars: _angular_core.Signal<AvatarData[]>;
+    /** Computed count of remaining avatars not shown */
+    readonly remainingCount: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarGroupComponent, "pe-avatar-group", never, { "avatars": { "alias": "avatars"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "maxVisible": { "alias": "maxVisible"; "required": false; "isSignal": true; }; "stacked": { "alias": "stacked"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface BreadcrumbItem {
+    label: string;
+    href?: string;
+    routerLink?: string | any[];
+    icon?: string;
+}
+type BreadcrumbSeparator = 'chevron_right' | 'slash' | 'dot';
+/**
+ * Breadcrumb component for displaying navigation hierarchy.
+ * Supports responsive collapsing on mobile devices and customizable separators.
+ *
+ * @example
+ * ```html
+ * <pe-breadcrumb
+ *   [items]="[
+ *     { label: 'Home', href: '/' },
+ *     { label: 'Products', href: '/products' },
+ *     { label: 'Current Page' }
+ *   ]"
+ * />
+ * ```
+ */
+declare class BreadcrumbComponent {
+    /** Array of breadcrumb items to display */
+    items: _angular_core.InputSignal<BreadcrumbItem[]>;
+    /** Separator type between breadcrumb items */
+    separator: _angular_core.InputSignal<BreadcrumbSeparator>;
+    /** Maximum number of items to show before collapsing (for responsive behavior) */
+    maxItems: _angular_core.InputSignal<number | undefined>;
+    /** Check if an item is the last item */
+    isLastItem(index: number): boolean;
+    /** Check if an item should be shown on mobile (first, last, or within maxItems) */
+    shouldShowOnMobile(index: number): boolean;
+    /** Check if ellipsis should be shown on mobile */
+    shouldShowEllipsisOnMobile(): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbComponent, "pe-breadcrumb", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "maxItems": { "alias": "maxItems"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A reusable button component that supports various themes, sizes, and states.
+ * @example
+ * <uds-button size="md" theme="fill-purple">Click me</uds-button>
+ */
+declare class ButtonComponent {
+    /** The size of the button */
+    size: _angular_core.InputSignal<UiSize>;
+    /** The visual theme of the button */
+    theme: _angular_core.InputSignal<UiTheme>;
+    /** Whether the button only contains an icon */
+    iconOnly: _angular_core.InputSignal<boolean>;
+    /** Whether the button content should be stacked vertically (only applies to lg size) */
+    vertical: _angular_core.InputSignal<boolean>;
+    /** Whether the button is disabled */
+    disabled: _angular_core.InputSignal<boolean>;
+    /** The button type attribute */
+    type: _angular_core.InputSignal<"button" | "submit" | "reset">;
+    /** Optional aria-label for accessibility */
+    ariaLabel: _angular_core.InputSignal<string | undefined>;
+    /** Click event emitter with proper type safety */
+    buttonClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    /** Handles the click event and prevents it if button is disabled */
+    protected handleClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "pe-button", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "iconOnly": { "alias": "iconOnly"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "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; }; }, { "buttonClick": "buttonClick"; }, never, ["*"], true, never>;
+}
+
+type CalendarMode = 'date' | 'time' | 'datetime';
+interface CalendarDay {
+    date: Date;
+    isCurrentMonth: boolean;
+    isToday: boolean;
+    isSelected: boolean;
+    isDisabled: boolean;
+}
+interface TimeSelection {
+    hour: number;
+    minute: number;
+}
+/**
+ * Calendar component. Implements FormValueControl&lt;Date | null&gt; for Signal Forms [formField].
+ * Use [(value)] or [formField]="myForm().date". Form model field should be Date | null.
+ */
+declare class CalendarComponent implements FormValueControl<Date | null> {
+    readonly mode: _angular_core.InputSignal<CalendarMode>;
+    readonly value: _angular_core.ModelSignal<Date | null>;
+    readonly size: _angular_core.InputSignal<UiSize>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly minDate: _angular_core.InputSignal<Date | null>;
+    readonly maxDate: _angular_core.InputSignal<Date | null>;
+    readonly minTime: _angular_core.InputSignal<Date | null>;
+    readonly maxTime: _angular_core.InputSignal<Date | null>;
+    readonly locale: _angular_core.InputSignal<string>;
+    readonly showCalendarIcon: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    readonly isOpen: _angular_core.WritableSignal<boolean>;
+    readonly currentMonth: _angular_core.WritableSignal<Date>;
+    readonly selectedTime: _angular_core.WritableSignal<TimeSelection | null>;
+    readonly buttonSize: _angular_core.Signal<UiSize>;
+    readonly iconSize: _angular_core.Signal<IconSize>;
+    readonly defaultPlaceholder: _angular_core.Signal<string>;
+    readonly displayValue: _angular_core.Signal<string>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly resolvedErrorText: _angular_core.Signal<string | null>;
+    readonly describedBy: _angular_core.Signal<string | undefined>;
+    readonly calendarDays: _angular_core.Signal<CalendarDay[]>;
+    readonly monthYearLabel: _angular_core.Signal<string>;
+    readonly hourOptions: _angular_core.Signal<number[]>;
+    readonly minuteOptions: _angular_core.Signal<number[]>;
+    readonly selectedHour: _angular_core.Signal<number>;
+    readonly selectedMinute: _angular_core.Signal<number>;
+    readonly valueChange: _angular_core.OutputEmitterRef<Date | null>;
+    readonly opened: _angular_core.OutputEmitterRef<void>;
+    readonly closed: _angular_core.OutputEmitterRef<void>;
+    constructor();
+    /**
+     * Closes the CDK menu by simulating an Escape key press.
+     * This lets the CDK handle all focus and cleanup logic.
+     */
+    private closeMenuViaEscape;
+    isDateDisabled(date: Date): boolean;
+    isTimeDisabled(hour: number, minute: number): boolean;
+    selectDate(date: Date): void;
+    selectTime(hour: number, minute: number): void;
+    previousMonth(): void;
+    nextMonth(): void;
+    selectToday(): void;
+    clear(): void;
+    open(): void;
+    close(): void;
+    onMenuOpened(): void;
+    onMenuClosed(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarComponent, "pe-calendar", never, { "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "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; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "minTime": { "alias": "minTime"; "required": false; "isSignal": true; }; "maxTime": { "alias": "maxTime"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "showCalendarIcon": { "alias": "showCalendarIcon"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; "opened": "opened"; "closed": "closed"; }, never, never, true, never>;
+}
+
+type CardDirection = 'horizontal' | 'vertical';
+type CardCaptionSize = 'default' | 'sm';
+type ActionsDistribution = 'default' | 'equal';
+type MediaAspectRatio = 'default' | 'square' | 'portrait';
+declare class CardComponent {
+    focused: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    disabled: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    cardDirection: _angular_core.InputSignal<CardDirection>;
+    cardCaptionSize: _angular_core.InputSignal<CardCaptionSize>;
+    footerDist: _angular_core.InputSignal<ActionsDistribution>;
+    mediaAspectRatio: _angular_core.InputSignal<MediaAspectRatio>;
+    mediaBlur: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    mediaGrayscale: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    cardCaption: _angular_core.InputSignal<string>;
+    cardTitle: _angular_core.InputSignal<string>;
+    cardTitleSingleLine: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    cardSubtitle: _angular_core.InputSignal<string>;
+    cardSubtitleSingleLine: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    loading: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "pe-card", never, { "focused": { "alias": "focused"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "cardDirection": { "alias": "cardDirection"; "required": false; "isSignal": true; }; "cardCaptionSize": { "alias": "cardCaptionSize"; "required": false; "isSignal": true; }; "footerDist": { "alias": "footerDist"; "required": false; "isSignal": true; }; "mediaAspectRatio": { "alias": "mediaAspectRatio"; "required": false; "isSignal": true; }; "mediaBlur": { "alias": "mediaBlur"; "required": false; "isSignal": true; }; "mediaGrayscale": { "alias": "mediaGrayscale"; "required": false; "isSignal": true; }; "cardCaption": { "alias": "cardCaption"; "required": false; "isSignal": true; }; "cardTitle": { "alias": "cardTitle"; "required": false; "isSignal": true; }; "cardTitleSingleLine": { "alias": "cardTitleSingleLine"; "required": false; "isSignal": true; }; "cardSubtitle": { "alias": "cardSubtitle"; "required": false; "isSignal": true; }; "cardSubtitleSingleLine": { "alias": "cardSubtitleSingleLine"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["[udsCardMedia]", "[udsCardMediaOverlay]", "[udsCardMediaAction]", "[udsCardFooter]"], true, never>;
+}
+
+declare class CarouselItemComponent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselItemComponent, "pe-carousel-item", never, {}, {}, never, ["*"], true, never>;
+}
+declare class CarouselComponent implements AfterViewInit, OnDestroy {
+    options: _angular_core.InputSignal<Options>;
+    autoMount: _angular_core.InputSignal<boolean>;
+    mounted: _angular_core.OutputEmitterRef<Splide>;
+    private carousel;
+    private items;
+    private instance;
+    constructor();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    getInstance(): Splide | null;
+    goNext(): void;
+    goPrev(): void;
+    goTo(index: number): void;
+    mount(): void;
+    private init;
+    private updateCarouselOnItemsChange;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CarouselComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CarouselComponent, "pe-carousel", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "autoMount": { "alias": "autoMount"; "required": false; "isSignal": true; }; }, { "mounted": "mounted"; }, ["items"], ["*"], true, never>;
+}
+
+type CheckboxZoneType = 'none' | 'accessible' | 'visible' | 'checked-visible';
+/**
+ * Checkbox component. Implements FormCheckboxControl for Signal Forms [formField].
+ * Use [(checked)] or [formField]="myForm().acceptTerms". No value property.
+ * Uses shared form field label and helper for alignment with input, textarea, radio-group.
+ */
+declare class CheckboxComponent implements FormCheckboxControl {
+    checked: _angular_core.ModelSignal<boolean>;
+    disabled: _angular_core.ModelSignal<boolean>;
+    indeterminate: _angular_core.ModelSignal<boolean>;
+    zone: _angular_core.InputSignal<CheckboxZoneType>;
+    size: _angular_core.InputSignal<UiCheckboxSize>;
+    label: _angular_core.InputSignal<string | null>;
+    helperText: _angular_core.InputSignal<string | null>;
+    required: _angular_core.InputSignal<boolean>;
+    error: _angular_core.InputSignal<boolean>;
+    errorText: _angular_core.InputSignal<string | null>;
+    invalid: _angular_core.InputSignal<boolean>;
+    errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly resolvedErrorText: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "pe-checkbox", never, { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "zone": { "alias": "zone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "disabled": "disabledChange"; "indeterminate": "indeterminateChange"; }, never, ["*"], true, never>;
+}
+
+type CollapseVariant = 'text' | 'icon';
+/**
+ * A collapsible content component that supports both text and icon variants.
+ * Uses CSS transitions for smooth animations and provides accessibility features.
+ *
+ * @example
+ * ```html
+ * <pe-collapse [maxHeight]="300" variant="text">
+ *   <div>Collapsible content here</div>
+ * </pe-collapse>
+ * ```
+ */
+declare class CollapseComponent implements AfterViewInit {
+    private readonly destroyRef;
+    content: ElementRef<HTMLDivElement>;
+    /**
+     * The visual variant of the collapse toggle.
+     * @default 'text'
+     */
+    variant: _angular_core.InputSignal<CollapseVariant>;
+    /**
+     * Controls the collapsed state of the component.
+     * @default true
+     */
+    collapsed: _angular_core.ModelSignal<boolean>;
+    /**
+     * Maximum height of the content when collapsed.
+     * @default 200
+     */
+    maxHeight: _angular_core.InputSignal<number>;
+    /**
+     * Custom label for the expand action.
+     * @default 'See more'
+     */
+    expandLabel: _angular_core.InputSignal<string>;
+    /**
+     * Custom label for the collapse action.
+     * @default 'See less'
+     */
+    collapseLabel: _angular_core.InputSignal<string>;
+    /** Current full height of the content */
+    fullHeight: _angular_core.WritableSignal<number>;
+    /** Whether the content is collapsible based on its height */
+    isCollapsible: _angular_core.Signal<boolean>;
+    ngAfterViewInit(): void;
+    /** Updates the full height of the content */
+    private updateFullHeight;
+    /** Toggles the collapsed state */
+    toggle(): void;
+    onToggleKeydown(event: KeyboardEvent): void;
+    computedClasses: _angular_core.Signal<{
+        'pe-collapse': boolean;
+        'pe-collapse--collapsed': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CollapseComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CollapseComponent, "pe-collapse", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "collapsed": { "alias": "collapsed"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": true; "isSignal": true; }; "expandLabel": { "alias": "expandLabel"; "required": false; "isSignal": true; }; "collapseLabel": { "alias": "collapseLabel"; "required": false; "isSignal": true; }; }, { "collapsed": "collapsedChange"; }, never, ["*"], true, never>;
+}
+
+type ListItemTheme = 'ghost-white' | 'transparent-white' | 'outline-white' | 'outline-purple';
+declare class ListItemComponent {
+    checkbox: _angular_core.Signal<CheckboxComponent | undefined>;
+    theme: _angular_core.InputSignal<ListItemTheme>;
+    disabled: _angular_core.InputSignal<boolean>;
+    hideFocusOutline: _angular_core.InputSignal<boolean>;
+    selected: _angular_core.InputSignal<boolean>;
+    loading: _angular_core.InputSignal<boolean>;
+    clickHandler(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListItemComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListItemComponent, "pe-list-item", never, { "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "hideFocusOutline": { "alias": "hideFocusOutline"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, ["checkbox"], ["[pe-list-item-before-label]", "[pe-list-item-label]", "[pe-list-item-after-label]"], true, never>;
+}
+
+/**
+ * Represents a single item in the dropdown menu.
+ */
+type DropdownItem = {
+    /** Display text for the dropdown item */
+    label: string;
+    /** Optional value associated with the item */
+    value?: string;
+    /** Icons to display on the left side of the item */
+    leftIcons?: IconName[];
+    /** Icons to display on the right side of the item */
+    rightIcons?: IconName[];
+    /** Whether the item is disabled and cannot be selected */
+    disabled?: boolean;
+};
+/**
+ * A customizable dropdown component that displays a list of selectable items.
+ *
+ * Features:
+ * - Configurable themes (ghost-white, transparent-white)
+ * - Icon support for items and trigger button
+ * - Customizable trigger appearance
+ * - Disabled item support
+ * - Two-way binding for selected item
+ *
+ * @example
+ * ```html
+ * <!-- Basic usage -->
+ * <uds-dropdown
+ *   [items]="dropdownItems"
+ *   [theme]="'transparent-white'"
+ *   (selectedItemChange)="onItemSelected($event)">
+ * </uds-dropdown>
+ *
+ * <!-- More options menu -->
+ * <uds-dropdown
+ *   [items]="actionItems"
+ *   [onlyMenuTriggerIcon]="'more_options'">
+ * </uds-dropdown>
+ * ```
+ */
+declare class DropdownComponent {
+    /**
+     * The visual theme for the dropdown.
+     * @default 'ghost-white'
+     */
+    theme: _angular_core.InputSignal<ListItemTheme>;
+    /**
+     * Array of items to display in the dropdown menu.
+     * @default []
+     */
+    items: _angular_core.InputSignal<DropdownItem[]>;
+    /**
+     * Whether the dropdown is disabled.
+     * @default false
+     */
+    disabled: _angular_core.InputSignal<boolean>;
+    /**
+     * Overrides the icons of the selected item in the trigger button.
+     * Can override leftIcons, rightIcons, or both.
+     * @default {}
+     *
+     * @example
+     * ```typescript
+     * menuTriggerIcons = {
+     *  chevron_down
+     * }
+     * ```
+     */
+    menuTriggerIcons: _angular_core.InputSignal<Pick<DropdownItem, "leftIcons" | "rightIcons">>;
+    /**
+     * Shows only a single icon in the trigger button, hiding the selected item's label and icons.
+     * Commonly used with 'more_options' for action menus.
+     * @default undefined
+     *
+     * @example
+     * ```typescript
+     * triggerIconOnly = 'more_options'
+     * ```
+     */
+    triggerIconOnly: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Accessible label for the icon-only trigger button.
+     * @default 'Open menu'
+     */
+    iconOnlyLabel: _angular_core.InputSignal<string>;
+    /**
+     * The index of the currently selected item.
+     * Supports two-way binding with [(selectedIndex)].
+     * @default 0
+     */
+    selectedIndex: _angular_core.ModelSignal<number>;
+    /**
+     * The currently selected item with any trigger icon overrides applied.
+     */
+    selectedItem: _angular_core.Signal<{
+        leftIcons?: IconName[];
+        rightIcons?: IconName[];
+        /** Display text for the dropdown item */
+        label: string;
+        /** Optional value associated with the item */
+        value?: string;
+        /** Whether the item is disabled and cannot be selected */
+        disabled?: boolean;
+    }>;
+    /**
+     * Right icons for the trigger: when default is chevron_down, shows chevron_down when closed
+     * and chevron_up when open. Otherwise uses selectedItem().rightIcons as-is.
+     */
+    triggerRightIcons: _angular_core.Signal<string[]>;
+    /**
+     * Tracks whether the menu is currently open for ARIA.
+     */
+    isOpen: _angular_core.WritableSignal<boolean>;
+    /**
+     * Stable id used to link the trigger to the menu container.
+     */
+    readonly menuId: string;
+    /**
+     * Emitted when a new item is selected from the dropdown.
+     */
+    selectedItemChange: _angular_core.OutputEmitterRef<DropdownItem>;
+    /**
+     * Handles the selection of a dropdown item.
+     * @param index - The index of the selected item
+     */
+    handleItemTriggered(index: number): void;
+    onMenuOpened(): void;
+    onMenuClosed(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "pe-dropdown", never, { "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "items": { "alias": "items"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "menuTriggerIcons": { "alias": "menuTriggerIcons"; "required": false; "isSignal": true; }; "triggerIconOnly": { "alias": "triggerIconOnly"; "required": false; "isSignal": true; }; "iconOnlyLabel": { "alias": "iconOnlyLabel"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "selectedItemChange": "selectedItemChange"; }, never, never, true, never>;
+}
+
+/** Border and hover style: border-only (hover = border only), subtle-tint (hover = border + 5% fill). */
+type FileInputAppearance = 'border-only' | 'subtle-tint';
+/**
+ * File input component with label, helper/error text, and optional slots.
+ * Implements FormValueControl<FileList | null> for use with Signal Forms [formField].
+ *
+ * Uses hidden native file input + visible trigger + selected file label.
+ * Content projection: [pe-file-input-left-elements], [pe-file-input-right-elements].
+ */
+declare class FileInputComponent implements FormValueControl<FileList | null> {
+    readonly size: _angular_core.InputSignal<UiSize>;
+    readonly appearance: _angular_core.InputSignal<FileInputAppearance>;
+    readonly accept: _angular_core.InputSignal<string>;
+    readonly multiple: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    /** Placeholder when no file is selected (e.g. "Choose file" or "No file chosen"). */
+    readonly placeholderText: _angular_core.InputSignal<string>;
+    readonly controlId: _angular_core.InputSignal<string | undefined>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<FileList | null>;
+    protected readonly fileInputRef: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly effectiveControlId: _angular_core.Signal<string>;
+    protected readonly effectiveHelperId: _angular_core.Signal<string>;
+    protected readonly effectiveErrorId: _angular_core.Signal<string>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    /** Display text for selected file(s). */
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    readonly inputBlur: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly inputFocus: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly valueChange: _angular_core.OutputEmitterRef<FileList | null>;
+    constructor();
+    onFileChange(event: Event): void;
+    onBlur(event: FocusEvent): void;
+    onFocus(event: FocusEvent): void;
+    triggerClick(): void;
+    focus(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileInputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileInputComponent, "pe-file-input", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "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; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "placeholderText": { "alias": "placeholderText"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "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; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "value": "valueChange"; "inputBlur": "inputBlur"; "inputFocus": "inputFocus"; "valueChange": "valueChange"; }, never, ["[pe-file-input-left-elements]", "[pe-file-input-right-elements]"], true, never>;
+}
+
+declare class FooterComponent {
+    copyrightText: _angular_core.InputSignal<string>;
+    socialLinks: _angular_core.InputSignal<{
+        url: string;
+        icon: IconName;
+    }[]>;
+    links: _angular_core.InputSignal<{
+        url: string;
+        text: string;
+    }[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FooterComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FooterComponent, "pe-footer", never, { "copyrightText": { "alias": "copyrightText"; "required": false; "isSignal": true; }; "socialLinks": { "alias": "socialLinks"; "required": false; "isSignal": true; }; "links": { "alias": "links"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/** Place on the element projected into [pe-hero-badges] so the hero can detect custom badges content. */
+declare class PeHeroBadgesSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PeHeroBadgesSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PeHeroBadgesSlotDirective, "[pe-hero-badges]", never, {}, {}, never, never, true, never>;
+}
+/** Place on the element projected into [pe-hero-title] so the hero can detect custom title content. */
+declare class PeHeroTitleSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PeHeroTitleSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PeHeroTitleSlotDirective, "[pe-hero-title]", never, {}, {}, never, never, true, never>;
+}
+/** Place on the element projected into [pe-hero-subtitle] so the hero can detect custom subtitle content. */
+declare class PeHeroSubtitleSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PeHeroSubtitleSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PeHeroSubtitleSlotDirective, "[pe-hero-subtitle]", never, {}, {}, never, never, true, never>;
+}
+/** Place on the element projected into [pe-hero-actions] so the hero can detect custom actions content. */
+declare class PeHeroActionsSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PeHeroActionsSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PeHeroActionsSlotDirective, "[pe-hero-actions]", never, {}, {}, never, never, true, never>;
+}
+/** Place on the element projected into [pe-hero-content] for optional extra content (e.g. between subtitle and actions). */
+declare class PeHeroContentSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PeHeroContentSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<PeHeroContentSlotDirective, "[pe-hero-content]", never, {}, {}, never, never, true, never>;
+}
+
+interface HeroAction {
+    label: string;
+    href?: string;
+    routerLink?: string | string[];
+    icon?: string;
+    theme?: UiTheme;
+    size?: UiSize;
+}
+type HeroAlignment = 'left' | 'center' | 'right';
+type HeroSize = 'sm' | 'md' | 'lg';
+/**
+ * Hero component for displaying prominent hero sections with title, description,
+ * call-to-action buttons, optional badges, and background image support.
+ * Fully responsive across mobile, tablet, and desktop.
+ *
+ * When slots are not projected, inputs are used (title, subtitle, badges, primaryAction, secondaryAction).
+ * Content projection slots: pe-hero-badges, pe-hero-title, pe-hero-subtitle, pe-hero-actions, pe-hero-content.
+ *
+ * @example
+ * ```html
+ * <pe-hero
+ *   title="Welcome"
+ *   subtitle="Build amazing experiences"
+ *   [primaryAction]="{ label: 'Get Started', href: '/signup' }"
+ *   [badges]="['New', 'Featured']"
+ * />
+ * ```
+ */
+declare class HeroComponent {
+    /** Main headline text */
+    title: _angular_core.InputSignal<string>;
+    /** Supporting description text */
+    subtitle: _angular_core.InputSignal<string | undefined>;
+    /** Primary call-to-action button */
+    primaryAction: _angular_core.InputSignal<HeroAction | undefined>;
+    /** Secondary call-to-action button */
+    secondaryAction: _angular_core.InputSignal<HeroAction | undefined>;
+    /** Badge/pill labels to display above the title */
+    badges: _angular_core.InputSignal<string[]>;
+    /** Background image URL */
+    backgroundImage: _angular_core.InputSignal<string | undefined>;
+    /**
+     * CSS gradient or color for the overlay on top of the background image.
+     * E.g. "linear-gradient(180deg, transparent 0%, rgba(0,0,0,0.7) 100%)" or "rgba(0,0,0,0.5)".
+     * When unset, a default dark overlay is used when a background image is present.
+     */
+    backgroundOverlayGradient: _angular_core.InputSignal<string | undefined>;
+    /**
+     * CSS filter applied to the background image (e.g. "brightness(0.8)", "blur(2px)", "grayscale(0.3)").
+     * Combine multiple: "brightness(0.7) contrast(1.1)".
+     */
+    backgroundFilter: _angular_core.InputSignal<string | undefined>;
+    /** Text and content alignment */
+    alignment: _angular_core.InputSignal<HeroAlignment>;
+    /** Hero section size variant */
+    size: _angular_core.InputSignal<HeroSize>;
+    /** Whether hero takes full viewport height */
+    fullHeight: _angular_core.InputSignal<boolean>;
+    readonly badgesSlot: _angular_core.Signal<PeHeroBadgesSlotDirective | undefined>;
+    readonly titleSlot: _angular_core.Signal<PeHeroTitleSlotDirective | undefined>;
+    readonly subtitleSlot: _angular_core.Signal<PeHeroSubtitleSlotDirective | undefined>;
+    readonly actionsSlot: _angular_core.Signal<PeHeroActionsSlotDirective | undefined>;
+    readonly contentSlot: _angular_core.Signal<PeHeroContentSlotDirective | undefined>;
+    readonly hasBadgesSlot: _angular_core.Signal<boolean>;
+    readonly hasTitleSlot: _angular_core.Signal<boolean>;
+    readonly hasSubtitleSlot: _angular_core.Signal<boolean>;
+    readonly hasActionsSlot: _angular_core.Signal<boolean>;
+    readonly hasContentSlot: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeroComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeroComponent, "pe-hero", never, { "title": { "alias": "title"; "required": true; "isSignal": true; }; "subtitle": { "alias": "subtitle"; "required": false; "isSignal": true; }; "primaryAction": { "alias": "primaryAction"; "required": false; "isSignal": true; }; "secondaryAction": { "alias": "secondaryAction"; "required": false; "isSignal": true; }; "badges": { "alias": "badges"; "required": false; "isSignal": true; }; "backgroundImage": { "alias": "backgroundImage"; "required": false; "isSignal": true; }; "backgroundOverlayGradient": { "alias": "backgroundOverlayGradient"; "required": false; "isSignal": true; }; "backgroundFilter": { "alias": "backgroundFilter"; "required": false; "isSignal": true; }; "alignment": { "alias": "alignment"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "fullHeight": { "alias": "fullHeight"; "required": false; "isSignal": true; }; }, {}, ["badgesSlot", "titleSlot", "subtitleSlot", "actionsSlot", "contentSlot"], ["[pe-hero-badges]", "[pe-hero-title]", "[pe-hero-subtitle]", "[pe-hero-content]", "[pe-hero-actions]"], true, never>;
+}
+
+/**
+ * Directive to handle image loading errors and display placeholders
+ */
+declare class ImageNotFoundDirective {
+    showPlaceholder: _angular_core.InputSignal<boolean>;
+    imageNotFound: _angular_core.WritableSignal<boolean>;
+    visibility: _angular_core.WritableSignal<string>;
+    /**
+     * Handles image loading errors
+     * Hides the image and optionally shows placeholder
+     */
+    handleError(): void;
+    /**
+     * Handles successful image load
+     * Shows the image and removes placeholder
+     */
+    handleLoad(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageNotFoundDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<ImageNotFoundDirective, "[peCatchImageNotFound]", never, { "showPlaceholder": { "alias": "showPlaceholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type InputType = 'text' | 'password' | 'email' | 'number' | 'tel' | 'url';
+/** Border and hover style: border-only (hover = border only), subtle-tint (hover = border + 5% fill). */
+type InputAppearance = 'border-only' | 'subtle-tint';
+/**
+ * A reusable input component that follows UDS design system guidelines.
+ * Implements FormValueControl for use with Signal Forms [formField] directive.
+ *
+ * Use [(value)] for two-way binding, or bind with [formField]="myForm().email" for Signal Forms.
+ *
+ * Content projection: [pe-input-left-elements], [pe-input-right-elements].
+ */
+declare class InputComponent implements FormValueControl<string> {
+    readonly type: _angular_core.InputSignal<InputType>;
+    readonly size: _angular_core.InputSignal<UiSize>;
+    /** Border/hover style: border-only (hover = border only), subtle-tint (hover = border + 5% fill). */
+    readonly appearance: _angular_core.InputSignal<InputAppearance>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly maxLength: _angular_core.InputSignal<number | undefined>;
+    readonly minLength: _angular_core.InputSignal<number | undefined>;
+    readonly pattern: _angular_core.InputSignal<readonly RegExp[]>;
+    readonly autocomplete: _angular_core.InputSignal<string>;
+    /** When provided (e.g. by a parent form field), the input element uses this id instead of the internal one. */
+    readonly controlId: _angular_core.InputSignal<string | undefined>;
+    /** FormUiControl optional: bound by [formField] when invalid */
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    /** FormUiControl optional: bound by [formField] for validation errors */
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    /** FormUiControl optional: control sets on blur */
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<string>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly effectiveControlId: _angular_core.Signal<string>;
+    protected readonly effectiveHelperId: _angular_core.Signal<string>;
+    protected readonly effectiveErrorId: _angular_core.Signal<string>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isDirty: _angular_core.WritableSignal<boolean>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    readonly inputBlur: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly inputFocus: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    constructor();
+    onInput(event: Event): void;
+    onBlur(event: FocusEvent): void;
+    onFocus(event: FocusEvent): void;
+    /**
+     * Programmatically focuses the input element
+     */
+    focus(): void;
+    select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "pe-input", never, { "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "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; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "pattern": { "alias": "pattern"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "controlId": { "alias": "controlId"; "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; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "value": "valueChange"; "inputBlur": "inputBlur"; "inputFocus": "inputFocus"; "valueChange": "valueChange"; }, never, ["[pe-input-left-elements]", "[pe-input-right-elements]"], true, never>;
+}
+
+type ModalVariant = 'default' | 'success' | 'error' | 'custom' | 'bottom-sheet' | 'confirmation';
+declare class ModalComponent {
+    /** Whether the modal is open. Supports two-way binding with [(open)]. */
+    open: _angular_core.ModelSignal<boolean>;
+    /** Visual variant: default, success, error, custom, or bottom-sheet (mobile-only layout). */
+    variant: _angular_core.InputSignal<ModalVariant>;
+    /** Optional title shown in the header. */
+    title: _angular_core.InputSignal<string | undefined>;
+    /** Whether clicking the backdrop closes the modal. */
+    closeOnBackdropClick: _angular_core.InputSignal<boolean>;
+    /** Whether to show the close button in the header. */
+    showCloseButton: _angular_core.InputSignal<boolean>;
+    /** Label for the primary confirm action in the confirmation variant. */
+    confirmLabel: _angular_core.InputSignal<string>;
+    /** Label for the secondary cancel action in the confirmation variant. */
+    cancelLabel: _angular_core.InputSignal<string>;
+    /** Optional CSS class for the panel (e.g. for custom variant). */
+    customClass: _angular_core.InputSignal<string | undefined>;
+    /** Emitted when the modal is closed (button, backdrop, or escape). */
+    closed: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the user confirms in the confirmation variant. */
+    confirmed: _angular_core.OutputEmitterRef<void>;
+    /** Emitted when the user cancels in the confirmation variant. */
+    cancelled: _angular_core.OutputEmitterRef<void>;
+    readonly panelClass: _angular_core.Signal<string>;
+    readonly isConfirmation: _angular_core.Signal<boolean>;
+    readonly isSuccess: _angular_core.Signal<boolean>;
+    readonly isError: _angular_core.Signal<boolean>;
+    modalTitle: _angular_core.Signal<string | undefined>;
+    readonly titleId: string;
+    readonly bodyId: string;
+    close(): void;
+    onConfirm(): void;
+    onCancel(): void;
+    onBackdropClick(event: MouseEvent): void;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ModalComponent, "pe-modal", never, { "open": { "alias": "open"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "showCloseButton": { "alias": "showCloseButton"; "required": false; "isSignal": true; }; "confirmLabel": { "alias": "confirmLabel"; "required": false; "isSignal": true; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; "isSignal": true; }; "customClass": { "alias": "customClass"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "closed": "closed"; "confirmed": "confirmed"; "cancelled": "cancelled"; }, never, ["*", "[pe-modal-footer]"], true, never>;
+}
+
+/** Place on the element projected into [pe-navbar-logo] so the navbar can detect logo content. */
+declare class NavbarLogoSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavbarLogoSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavbarLogoSlotDirective, "[pe-navbar-logo]", never, {}, {}, never, never, true, never>;
+}
+/** Place on the element projected into [pe-navbar-search] so the navbar can show the mobile search toggle. */
+declare class NavbarSearchSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavbarSearchSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavbarSearchSlotDirective, "[pe-navbar-search]", never, {}, {}, never, never, true, never>;
+}
+/** Place on the element projected into [pe-navbar-avatar] so the navbar can detect avatar content. */
+declare class NavbarAvatarSlotDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavbarAvatarSlotDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NavbarAvatarSlotDirective, "[pe-navbar-avatar]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NavbarComponent {
+    /** Default logo link href when logo slot is not projected. */
+    logoHref: _angular_core.InputSignal<string>;
+    /** Default logo image src when logo slot is not projected. */
+    logoSrc: _angular_core.InputSignal<string | undefined>;
+    /** Default logo image alt when logo slot is not projected. */
+    logoAlt: _angular_core.InputSignal<string>;
+    /** Default avatar image src when avatar slot is not projected. */
+    avatarSrc: _angular_core.InputSignal<string | undefined>;
+    /** Default avatar initials when avatar slot is not projected and no image. */
+    avatarInitials: _angular_core.InputSignal<string | undefined>;
+    /** Default avatar image alt when avatar slot is not projected. */
+    avatarAlt: _angular_core.InputSignal<string>;
+    /** For aria-expanded on the toggle button */
+    sidebarOpen: _angular_core.InputSignal<boolean>;
+    /** When true, show the sidebar toggle button even when a logo slot is projected. */
+    showSidebarToggle: _angular_core.InputSignal<boolean>;
+    /** Emitted when the user clicks the sidebar toggle. Parent should flip the open state. */
+    sidebarToggle: _angular_core.OutputEmitterRef<void>;
+    readonly logoSlot: _angular_core.Signal<NavbarLogoSlotDirective | undefined>;
+    readonly searchSlot: _angular_core.Signal<NavbarSearchSlotDirective | undefined>;
+    readonly avatarSlot: _angular_core.Signal<NavbarAvatarSlotDirective | undefined>;
+    readonly hasLogoSlot: _angular_core.Signal<boolean>;
+    readonly hasSearchSlot: _angular_core.Signal<boolean>;
+    readonly hasAvatarSlot: _angular_core.Signal<boolean>;
+    readonly showToggle: _angular_core.Signal<boolean>;
+    readonly searchExpanded: _angular_core.WritableSignal<boolean>;
+    toggleSearch(): void;
+    toggleSidebar(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavbarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavbarComponent, "pe-navbar", never, { "logoHref": { "alias": "logoHref"; "required": false; "isSignal": true; }; "logoSrc": { "alias": "logoSrc"; "required": false; "isSignal": true; }; "logoAlt": { "alias": "logoAlt"; "required": false; "isSignal": true; }; "avatarSrc": { "alias": "avatarSrc"; "required": false; "isSignal": true; }; "avatarInitials": { "alias": "avatarInitials"; "required": false; "isSignal": true; }; "avatarAlt": { "alias": "avatarAlt"; "required": false; "isSignal": true; }; "sidebarOpen": { "alias": "sidebarOpen"; "required": false; "isSignal": true; }; "showSidebarToggle": { "alias": "showSidebarToggle"; "required": false; "isSignal": true; }; }, { "sidebarToggle": "sidebarToggle"; }, ["logoSlot", "searchSlot", "avatarSlot"], ["[pe-navbar-logo]", "[pe-navbar-search]", "[pe-navbar-avatar]"], true, never>;
+}
+
+type PillSize = 'md' | 'lg';
+type PillVariant = 'interactive' | 'interactive-rounded' | 'read-only' | 'dismissible' | 'selectable';
+type PillTheme = 'fill-white' | 'fill-black' | 'fill-purple' | 'fill-red' | 'fill-green' | 'transparent-white' | 'transparent-purple' | 'transparent-red' | 'transparent-green' | 'stroke-white' | 'outline-white' | 'outline-purple' | 'outline-red' | 'outline-green';
+declare class PillComponent {
+    variant: _angular_core.InputSignal<PillVariant>;
+    theme: _angular_core.InputSignal<PillTheme>;
+    size: _angular_core.InputSignal<PillSize>;
+    disabled: _angular_core.InputSignal<boolean>;
+    dismiss: _angular_core.OutputEmitterRef<void>;
+    dismissibleButtonTheme: _angular_core.Signal<"ghost-purple" | "ghost-white" | "ghost-red" | "ghost-green">;
+    modifierClass: _angular_core.Signal<string[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PillComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PillComponent, "pe-pill", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; }, never, ["*"], true, never>;
+}
+
+type SalePosition = 'left' | 'right';
+type Currency = 'UOS' | string;
+declare class PriceButtonComponent {
+    readonly label: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<UiSize>;
+    readonly theme: _angular_core.InputSignal<UiTheme>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly salePosition: _angular_core.InputSignal<SalePosition>;
+    readonly price: _angular_core.InputSignal<number>;
+    readonly originalPrice: _angular_core.InputSignal<number>;
+    readonly discountBasis: _angular_core.InputSignal<number>;
+    readonly currency: _angular_core.InputSignal<string>;
+    readonly buttonClick: _angular_core.OutputEmitterRef<MouseEvent>;
+    protected handleClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PriceButtonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PriceButtonComponent, "pe-price-button", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "salePosition": { "alias": "salePosition"; "required": false; "isSignal": true; }; "price": { "alias": "price"; "required": false; "isSignal": true; }; "originalPrice": { "alias": "originalPrice"; "required": false; "isSignal": true; }; "discountBasis": { "alias": "discountBasis"; "required": false; "isSignal": true; }; "currency": { "alias": "currency"; "required": false; "isSignal": true; }; }, { "buttonClick": "buttonClick"; }, never, never, true, never>;
+}
+
+/**
+ * Extends Angular's CurrencyPipe to use the custom symbol 'ᕫ' for 'UOS' currency code.
+ * For all other codes, behaves exactly like CurrencyPipe.
+ */
+declare class CustomCurrencyPipe extends CurrencyPipe implements PipeTransform {
+    private static readonly UOS_SYMBOL;
+    transform(value: number | string, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): string | null;
+    transform(value: null | undefined, currencyCode?: string, display?: 'code' | 'symbol' | 'symbol-narrow' | string | boolean, digitsInfo?: string, locale?: string): null;
+    private separateCurrencyAndPrice;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CustomCurrencyPipe, never>;
+    static ɵpipe: _angular_core.ɵɵPipeDeclaration<CustomCurrencyPipe, "peCurrency", true>;
+}
+
+/**
+ * Radio button for use inside a group. For Signal Forms use pe-radio-group with [formField].
+ * Use [(checked)] when controlling each radio manually, or place inside pe-radio-group for [formField] binding.
+ *
+ * @example
+ * <pe-radio value="option1" name="my-group" [checked]="isSelected">Option 1</pe-radio>
+ */
+declare class RadioComponent {
+    /**
+     * The value associated with this radio button.
+     * This value identifies the radio button within its group.
+     */
+    value: _angular_core.InputSignal<string>;
+    /**
+     * The name attribute for the radio button group.
+     * All radio buttons in the same group should share the same name.
+     */
+    name: _angular_core.InputSignal<string>;
+    /**
+     * Whether the radio button is disabled.
+     * @default false
+     */
+    disabled: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    /**
+     * Whether the radio button is currently checked/selected.
+     * This is a two-way binding that can be used with [(checked)].
+     */
+    checked: _angular_core.ModelSignal<boolean>;
+    /**
+     * Unique identifier for the radio button.
+     * If not provided, one will be auto-generated.
+     */
+    id: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Event emitted when the radio button is clicked.
+     * Useful for additional click handling beyond the default radio behavior.
+     */
+    click: _angular_core.OutputEmitterRef<MouseEvent>;
+    /**
+     * Emitted when this radio is selected (checked becomes true).
+     * Used by pe-radio-group to sync the group value.
+     */
+    selected: _angular_core.OutputEmitterRef<string>;
+    /**
+     * Internal signal for the unique ID
+     */
+    private readonly uniqueId;
+    /**
+     * Computed ID that uses provided ID or falls back to generated unique ID
+     */
+    readonly radioId: _angular_core.Signal<string>;
+    /**
+     * Computed ARIA attributes for accessibility
+     */
+    readonly ariaAttributes: _angular_core.Signal<{
+        'aria-checked': boolean;
+        'aria-disabled': boolean;
+        role: "radio";
+    }>;
+    /**
+     * Handles the radio button change event.
+     * Updates the checked state.
+     *
+     * @param event - The change event from the input element
+     */
+    onRadioChange(event: Event): void;
+    /**
+     * Handles click events on the radio button.
+     * Useful for additional click handling beyond the default radio behavior.
+     *
+     * @param event - The click event
+     */
+    onRadioClick(event: MouseEvent): void;
+    /**
+     * Handles keyboard events for accessibility.
+     * Supports Space and Enter keys for selection.
+     *
+     * @param event - The keyboard event
+     */
+    onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent, "pe-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "name": { "alias": "name"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "click": "click"; "selected": "selected"; }, never, ["*"], true, never>;
+}
+
+interface RadioGroupOption {
+    value: string;
+    label: string;
+}
+/**
+ * Radio group that holds the selected option value. Implements FormValueControl for Signal Forms [formField].
+ * Use [(value)] or [formField]="myForm().choice". Renders pe-radio per option; value is the selected option's value.
+ */
+declare class RadioGroupComponent implements FormValueControl<string | null> {
+    readonly name: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<RadioGroupOption[]>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent, "pe-radio-group", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "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; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+
+type RadialSize = 96 | 64 | 48 | 32 | 24 | 20 | 16;
+declare class RadialComponent {
+    readonly size: _angular_core.InputSignal<RadialSize>;
+    readonly infinite: _angular_core.InputSignalWithTransform<boolean, boolean>;
+    readonly percentage: _angular_core.InputSignal<number>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null>;
+    readonly lineWidth: _angular_core.Signal<number>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadialComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadialComponent, "pe-radial", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "infinite": { "alias": "infinite"; "required": false; "isSignal": true; }; "percentage": { "alias": "percentage"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type RichTextTone = 'default' | 'muted' | 'inverse';
+type RichTextSize = 'body-m' | 'body-l';
+/**
+ * Display-only rich text component. Renders sanitized HTML from the API (or from
+ * pe-rich-text-editor) with no Quill dependency. HTML is sanitized before rendering.
+ *
+ * Use [content] for HTML strings (e.g. from API or editor), or project markup via
+ * ng-content when content is empty.
+ */
+declare class RichTextComponent {
+    readonly content: _angular_core.InputSignal<string | null>;
+    readonly size: _angular_core.InputSignal<RichTextSize>;
+    private readonly domSanitizer;
+    protected readonly sanitizedContent: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RichTextComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RichTextComponent, "pe-rich-text", never, { "content": { "alias": "content"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type SkeletonVariant = 'rect' | 'text';
+type SkeletonBorderRadius = 'xs' | 'sm' | 'md' | 'lg' | 'full';
+declare class SkeletonComponent {
+    readonly variant: _angular_core.InputSignal<SkeletonVariant>;
+    readonly width: _angular_core.InputSignal<string | null>;
+    readonly height: _angular_core.InputSignal<string | null>;
+    readonly lines: _angular_core.InputSignal<number>;
+    readonly borderRadius: _angular_core.InputSignal<SkeletonBorderRadius | null>;
+    readonly show: _angular_core.InputSignal<boolean>;
+    readonly hostStyles: _angular_core.Signal<{
+        readonly width: string | null;
+        readonly height: string | null;
+    }>;
+    readonly lineWidths: _angular_core.Signal<string[]>;
+    readonly radiusClass: _angular_core.Signal<string | null>;
+    trackByIndex(index: number): number;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonComponent, "pe-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; }; "borderRadius": { "alias": "borderRadius"; "required": false; "isSignal": true; }; "show": { "alias": "show"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+type ToastKind = 'info' | 'success' | 'warning' | 'error';
+type ToastWithRole = {
+    readonly id: string;
+    readonly title?: string;
+    readonly message: string;
+    readonly kind: ToastKind;
+    readonly dismissible: boolean;
+    readonly role: 'status' | 'alert';
+    readonly icon: string;
+    readonly showIcon: boolean;
+};
+
+declare class ToastContainerComponent {
+    private readonly toastService;
+    readonly toasts: _angular_core.Signal<ToastWithRole[]>;
+    trackById(_: number, toast: ToastWithRole): string;
+    dismiss(id: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastContainerComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastContainerComponent, "pe-toast-container", never, {}, {}, never, never, true, never>;
+}
+
+type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
+declare class TooltipComponent {
+    text: _angular_core.InputSignal<string>;
+    position: _angular_core.InputSignal<TooltipPosition>;
+    disabled: _angular_core.InputSignal<boolean>;
+    showDelay: _angular_core.InputSignal<number>;
+    hideDelay: _angular_core.InputSignal<number>;
+    private readonly visible;
+    private showTimeoutId;
+    private hideTimeoutId;
+    readonly tooltipId: string;
+    get ariaDescribedBy(): string | null;
+    handlePointerEnter(): void;
+    handlePointerLeave(): void;
+    readonly isVisible: _angular_core.Signal<boolean>;
+    private scheduleShow;
+    private scheduleHide;
+    private cancelShow;
+    private cancelHide;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TooltipComponent, "pe-tooltip", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "showDelay": { "alias": "showDelay"; "required": false; "isSignal": true; }; "hideDelay": { "alias": "hideDelay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface SearchSelectOption {
+    label: string;
+    value: string;
+}
+/**
+ * Combobox: search input with filterable dropdown. User types to filter options and selects a result.
+ * Implements FormValueControl for use with Signal Forms [formField]. Use [(value)] for two-way binding.
+ */
+declare class SearchSelectComponent implements FormValueControl<string | null> {
+    readonly size: _angular_core.InputSignal<UiSize>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<SearchSelectOption[]>;
+    readonly minCharsToOpen: _angular_core.InputSignal<number>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string | null>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly query: _angular_core.WritableSignal<string>;
+    protected readonly isOpen: _angular_core.WritableSignal<boolean>;
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly highlightedIndex: _angular_core.WritableSignal<number>;
+    protected blurCloseTimeout: ReturnType<typeof setTimeout> | null;
+    protected readonly listId: string;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    protected readonly selectedOption: _angular_core.Signal<SearchSelectOption | null>;
+    protected readonly selectedLabel: _angular_core.Signal<string>;
+    protected readonly filteredOptions: _angular_core.Signal<SearchSelectOption[]>;
+    protected readonly displayText: _angular_core.Signal<string>;
+    protected readonly shouldShowPanel: _angular_core.Signal<boolean>;
+    protected readonly hasNoResults: _angular_core.Signal<boolean>;
+    protected readonly optionId: (index: number) => string;
+    protected readonly activeDescendantId: _angular_core.Signal<string | undefined>;
+    onInputValueChange(text: string): void;
+    onInputFocus(): void;
+    onInputBlur(): void;
+    onKeydown(event: KeyboardEvent): void;
+    selectOption(opt: SearchSelectOption): void;
+    private cancelBlurClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchSelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchSelectComponent, "pe-search-select", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "minCharsToOpen": { "alias": "minCharsToOpen"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+interface SelectOption extends DropdownItem {
+    /** Required value associated with the option */
+    value: string;
+}
+/**
+ * Form-friendly select built on the dropdown. Implements FormValueControl for Signal Forms [formField].
+ * Use [(value)] or [formField]="myForm().country".
+ *
+ * @example
+ * <pe-select label="Sort by" [options]="options" [(value)]="selected" />
+ */
+declare class SelectComponent implements FormValueControl<string | null> {
+    readonly size: _angular_core.InputSignal<UiSize>;
+    readonly theme: _angular_core.InputSignal<ListItemTheme>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly options: _angular_core.InputSignal<SelectOption[]>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    readonly value: _angular_core.ModelSignal<string | null>;
+    protected readonly selectedIndex: _angular_core.ModelSignal<number>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly items: _angular_core.Signal<DropdownItem[]>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    constructor();
+    /** Handles index changes coming from the dropdown */
+    protected onSelectedIndexChange(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SelectComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SelectComponent, "pe-select", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "errors": { "alias": "errors"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selectedIndex": "selectedIndexChange"; }, never, never, true, never>;
+}
+
+/**
+ * Generates unique IDs for form field elements (control, helper, error).
+ * Use this so label `for`, helper `id`, and `aria-describedby` stay in sync.
+ */
+declare function createFormFieldIds(prefix: string): {
+    controlId: string;
+    helperId: string;
+    errorId: string;
+};
+/**
+ * Builds the value for `aria-describedby` from helper and error IDs.
+ */
+declare function getFormFieldDescribedBy(helperId: string, errorId: string, hasHelperText: boolean, hasError: boolean, hasErrorText: boolean): string | undefined;
+
+/**
+ * Shared label for form fields (input, select, textarea).
+ * Renders label text and optional required indicator.
+ */
+declare class FormFieldLabelComponent {
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly for: _angular_core.InputSignal<string>;
+    readonly size: _angular_core.InputSignal<UiSize>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldLabelComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldLabelComponent, "pe-form-field-label", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "for": { "alias": "for"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Shared helper/error text for form fields (input, select, textarea).
+ * Shows error text when in error state, otherwise helper text.
+ */
+declare class FormFieldHelperComponent {
+    readonly id: _angular_core.InputSignal<string>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldHelperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldHelperComponent, "pe-form-field-helper", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+type SidebarItem = {
+    label: string;
+    value?: string;
+    leftIcons?: IconName[];
+    rightIcons?: IconName[];
+    disabled?: boolean;
+};
+declare class SidebarComponent {
+    items: _angular_core.InputSignal<SidebarItem[]>;
+    theme: _angular_core.InputSignal<ListItemTheme>;
+    selectedIndex: _angular_core.ModelSignal<number>;
+    open: _angular_core.ModelSignal<boolean>;
+    closeOnBackdropClick: _angular_core.InputSignal<boolean>;
+    hideItemFocusOutline: _angular_core.InputSignal<boolean>;
+    itemSelected: _angular_core.OutputEmitterRef<SidebarItem>;
+    close(): void;
+    onOverlayClick(): void;
+    onItemClick(item: SidebarItem, index: number): void;
+    onEscape(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarComponent, "pe-sidebar", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "theme": { "alias": "theme"; "required": false; "isSignal": true; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "closeOnBackdropClick": { "alias": "closeOnBackdropClick"; "required": false; "isSignal": true; }; "hideItemFocusOutline": { "alias": "hideItemFocusOutline"; "required": false; "isSignal": true; }; }, { "selectedIndex": "selectedIndexChange"; "open": "openChange"; "itemSelected": "itemSelected"; }, never, ["[pe-sidebar-header]", "[pe-sidebar-nav]", "[pe-sidebar-footer]"], true, never>;
+}
+
+type Status = 'confirm' | 'alert' | 'error' | 'pending' | 'info';
+declare class StatusComponent {
+    status: _angular_core.InputSignal<Status>;
+    customIcon: _angular_core.InputSignal<string | undefined>;
+    loadingAnimation: _angular_core.InputSignal<boolean>;
+    get icon(): IconName;
+    computedClasses: _angular_core.Signal<{
+        'pe-status': boolean;
+        'pe-status--confirm': boolean;
+        'pe-status--alert': boolean;
+        'pe-status--error': boolean;
+        'pe-status--pending': boolean;
+        'pe-status--info': boolean;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StatusComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StatusComponent, "pe-status", never, { "status": { "alias": "status"; "required": false; "isSignal": true; }; "customIcon": { "alias": "customIcon"; "required": false; "isSignal": true; }; "loadingAnimation": { "alias": "loadingAnimation"; "required": false; "isSignal": true; }; }, {}, never, ["[pe-status-title]", "[pe-status-subtitle]", "[pe-status-description]"], true, never>;
+}
+
+interface TableColumn {
+    id: string;
+    label: string;
+    sortable?: boolean;
+    filterable?: boolean;
+}
+type SortDirection = 'asc' | 'desc';
+/**
+ * Table component for tabular data with optional sort (per-column) and global filter.
+ * Uses semantic table markup; responsive with horizontal scroll on small viewports.
+ */
+declare class TableComponent {
+    readonly columns: _angular_core.InputSignal<TableColumn[]>;
+    readonly data: _angular_core.InputSignal<Record<string, unknown>[]>;
+    readonly sortColumn: _angular_core.ModelSignal<string | null>;
+    readonly sortDirection: _angular_core.ModelSignal<SortDirection>;
+    readonly filterPlaceholder: _angular_core.InputSignal<string>;
+    readonly filterLabel: _angular_core.InputSignal<string>;
+    readonly showGlobalFilter: _angular_core.InputSignal<boolean>;
+    readonly emptyMessage: _angular_core.InputSignal<string>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    readonly sortColumnChange: _angular_core.OutputEmitterRef<{
+        column: string | null;
+        direction: SortDirection;
+    }>;
+    readonly filterChange: _angular_core.OutputEmitterRef<string>;
+    protected readonly filterQuery: _angular_core.WritableSignal<string>;
+    protected readonly hasSortableColumn: _angular_core.Signal<boolean>;
+    protected readonly filteredData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly sortedData: _angular_core.Signal<Record<string, unknown>[]>;
+    protected readonly filterId: string;
+    getCellValue(row: Record<string, unknown>, columnId: string): unknown;
+    onFilterInput(value: string): void;
+    toggleSort(columnId: string): void;
+    getSortAriaSort(columnId: string): 'ascending' | 'descending' | 'none';
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableComponent, "pe-table", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "data": { "alias": "data"; "required": false; "isSignal": true; }; "sortColumn": { "alias": "sortColumn"; "required": false; "isSignal": true; }; "sortDirection": { "alias": "sortDirection"; "required": false; "isSignal": true; }; "filterPlaceholder": { "alias": "filterPlaceholder"; "required": false; "isSignal": true; }; "filterLabel": { "alias": "filterLabel"; "required": false; "isSignal": true; }; "showGlobalFilter": { "alias": "showGlobalFilter"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, { "sortColumn": "sortColumnChange"; "sortDirection": "sortDirectionChange"; "sortColumnChange": "sortColumnChange"; "filterChange": "filterChange"; }, never, never, true, never>;
+}
+
+/**
+ * When projected into pe-textarea, replaces the native textarea with custom content (e.g. Quill).
+ * Use with [pe-textarea-field] on the element to project.
+ */
+declare class TextareaFieldDirective {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaFieldDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TextareaFieldDirective, "[pe-textarea-field]", never, {}, {}, never, never, true, never>;
+}
+
+type TextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
+/**
+ * Reusable textarea. Implements FormValueControl for Signal Forms [formField].
+ * Use [(value)] for two-way binding or [formField]="myForm().message".
+ *
+ * Content projection: [pe-textarea-field] (replaces native textarea), [pe-textarea-left-elements], [pe-textarea-right-elements].
+ */
+declare class TextareaComponent implements FormValueControl<string> {
+    readonly size: _angular_core.InputSignal<UiSize>;
+    readonly error: _angular_core.InputSignal<boolean>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly readOnly: _angular_core.InputSignal<boolean>;
+    readonly required: _angular_core.InputSignal<boolean>;
+    readonly placeholder: _angular_core.InputSignal<string>;
+    readonly label: _angular_core.InputSignal<string | null>;
+    readonly helperText: _angular_core.InputSignal<string | null>;
+    readonly errorText: _angular_core.InputSignal<string | null>;
+    readonly maxLength: _angular_core.InputSignal<number | undefined>;
+    readonly minLength: _angular_core.InputSignal<number | undefined>;
+    readonly autocomplete: _angular_core.InputSignal<string>;
+    readonly rows: _angular_core.InputSignal<number>;
+    readonly resize: _angular_core.InputSignal<TextareaResize>;
+    /** When using [pe-textarea-field], pass focus state so the group border reflects it. */
+    readonly groupFocused: _angular_core.InputSignal<boolean | null>;
+    readonly invalid: _angular_core.InputSignal<boolean>;
+    readonly errors: _angular_core.InputSignal<readonly WithOptionalField<ValidationError>[]>;
+    readonly touched: _angular_core.ModelSignal<boolean>;
+    readonly value: _angular_core.ModelSignal<string>;
+    protected readonly customField: _angular_core.Signal<TextareaFieldDirective | undefined>;
+    protected readonly ids: {
+        controlId: string;
+        helperId: string;
+        errorId: string;
+    };
+    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
+    protected readonly isDirty: _angular_core.WritableSignal<boolean>;
+    protected readonly groupFocusedState: _angular_core.Signal<boolean>;
+    protected readonly hasError: _angular_core.Signal<boolean>;
+    protected readonly describedBy: _angular_core.Signal<string | undefined>;
+    readonly inputBlur: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly inputFocus: _angular_core.OutputEmitterRef<FocusEvent>;
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    constructor();
+    onInput(event: Event): void;
+    onBlur(event: FocusEvent): void;
+    onFocus(event: FocusEvent): void;
+    focus(): void;
+    select(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "pe-textarea", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "error": { "alias": "error"; "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; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "helperText": { "alias": "helperText"; "required": false; "isSignal": true; }; "errorText": { "alias": "errorText"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "rows": { "alias": "rows"; "required": false; "isSignal": true; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; "groupFocused": { "alias": "groupFocused"; "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; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "touched": "touchedChange"; "value": "valueChange"; "inputBlur": "inputBlur"; "inputFocus": "inputFocus"; "valueChange": "valueChange"; }, ["customField"], ["[pe-textarea-left-elements]", "[pe-textarea-field]", "[pe-textarea-right-elements]"], true, never>;
+}
+
+export { AccordionComponent, AccordionItemComponent, AreaCodeComponent, AvatarComponent, AvatarGroupComponent, BreadcrumbComponent, ButtonComponent, CalendarComponent, CardComponent, CarouselComponent, CarouselItemComponent, CheckboxComponent, CollapseComponent, CustomCurrencyPipe, DropdownComponent, FileInputComponent, FooterComponent, FormFieldHelperComponent, FormFieldLabelComponent, HeroComponent, IconComponent, ImageNotFoundDirective, InputComponent, ListItemComponent, ModalComponent, NavbarAvatarSlotDirective, NavbarComponent, NavbarLogoSlotDirective, NavbarSearchSlotDirective, PeHeroActionsSlotDirective, PeHeroBadgesSlotDirective, PeHeroContentSlotDirective, PeHeroSubtitleSlotDirective, PeHeroTitleSlotDirective, PillComponent, PriceButtonComponent, RadialComponent, RadioComponent, RadioGroupComponent, RichTextComponent, SearchSelectComponent, SelectComponent, SidebarComponent, SkeletonComponent, StatusComponent, TableComponent, TextareaComponent, TextareaFieldDirective, ToastContainerComponent, TooltipComponent, createFormFieldIds, getFormFieldDescribedBy };
+export type { ActionsDistribution, AvatarData, BreadcrumbItem, BreadcrumbSeparator, CalendarDay, CalendarMode, CardCaptionSize, CardDirection, CheckboxZoneType, CollapseVariant, Currency, DropdownItem, FileInputAppearance, HeroAction, HeroAlignment, HeroSize, IconName, IconSize, IconWeight, InputAppearance, InputType, ListItemTheme, MediaAspectRatio, ModalVariant, PillSize, PillTheme, PillVariant, RadioGroupOption, RichTextSize, RichTextTone, SalePosition, SearchSelectOption, SelectOption, SidebarItem, SkeletonBorderRadius, SkeletonVariant, SortDirection, Status, TableColumn, TextareaResize, TimeSelection, TooltipPosition };