import * as _angular_core from '@angular/core';
import { EnvironmentProviders, InjectionToken, Signal, Type, OnDestroy, ElementRef, TemplateRef, AfterContentChecked, OnInit } from '@angular/core';
import * as _eagami_ui from '@eagami/ui';
import { ControlValueAccessor } from '@angular/forms';

/**
 * BCP 47 locale tags supported out of the box. Consumers select one of these
 * via `provideEagamiUi({ locale })` or `EagamiI18nService.setLocale()`.
 */
type EagamiLocale = 'en' | 'de' | 'es-ES' | 'fr-FR' | 'is' | 'nl' | 'pl' | 'pt-BR' | 'el' | 'ru' | 'uk' | 'he' | 'ar' | 'hi' | 'zh-CN';
/**
 * Display metadata for a built-in locale: the language's name in its own
 * language and a representative flag emoji.
 */
interface EagamiLocaleMeta {
    locale: EagamiLocale;
    label: string;
    flag: string;
    /** Reading direction of the locale's script, for consumers wiring `dir`. */
    dir: 'ltr' | 'rtl';
}
/**
 * Display metadata for every built-in locale. The single source the Storybook
 * locale toolbar and any consumer-built language switcher derive from, so the
 * displayed list never drifts from the locales the library ships.
 */
declare const EAGAMI_LOCALE_META: readonly EagamiLocaleMeta[];
/**
 * Supported locales for language switchers, in display order. Derived from
 * `EAGAMI_LOCALE_META` so the two never drift.
 */
declare const EAGAMI_LOCALES: readonly EagamiLocale[];
/**
 * Every user-facing string baked into the component library, grouped by
 * component. Parameterized strings are functions so each locale controls its
 * own word order and pluralization.
 */
interface EagamiMessages {
    alert: {
        dismiss: string;
    };
    autocomplete: {
        empty: string;
    };
    avatarEditor: {
        upload: string;
        dropzone: string;
        canvas: string;
        canvasInstructions: string;
        change: string;
        revert: string;
        zoomOut: string;
        zoom: string;
        zoomIn: string;
        remove: string;
        invalidType: string;
        tooLarge: (maxMb: number) => string;
    };
    breadcrumbs: {
        label: string;
    };
    codeInput: {
        groupLabel: (length: number) => string;
        digitLabel: (index: number, length: number) => string;
    };
    commandPalette: {
        dialogLabel: string;
        searchPlaceholder: string;
        empty: string;
    };
    colorPicker: {
        dialogLabel: string;
        placeholder: string;
        clear: string;
        hue: string;
        saturationAndValue: string;
        saturationAndValueStatus: (saturation: number, value: number) => string;
        alpha: string;
        eyedropper: string;
        presets: string;
        toggleFormat: string;
    };
    dataTable: {
        noData: string;
    };
    /** Locale numeric formatting rules, used to group numbers even when the
     *  runtime's `Intl` lacks this locale's data (some browsers ship a reduced
     *  ICU that drops long-tail locales). */
    numberFormat: {
        /** Decimal mark, e.g. `.` (en) or `,` (de). */
        decimal: string;
        /** Grouping separator, e.g. `,` (en), `.` (de), or a no-break space (fr). */
        group: string;
        /** Digit-group sizes from the right: `[3]` for most locales, `[3, 2]` for
         *  Indian-style lakh/crore grouping. */
        grouping: readonly number[];
    };
    datePicker: {
        placeholder: string;
        dialogLabel: string;
        clear: string;
        previousYear: string;
        previousMonth: string;
        nextMonth: string;
        nextYear: string;
        today: string;
        /** Abbreviated weekday names, Sunday first (index 0), for the calendar
         *  header. Bundled so the calendar localizes even when the runtime's
         *  `Intl` lacks this locale's date data. */
        weekdaysShort: readonly string[];
        /** Full month names, January first (index 0), for the calendar heading and
         *  formatted values when `Intl` cannot localize this locale. */
        months: readonly string[];
    };
    dialog: {
        close: string;
    };
    drawer: {
        close: string;
    };
    dropdown: {
        placeholder: string;
    };
    fileUploader: {
        prompt: string;
        promptSingle: string;
        browse: string;
        removeFile: (name: string) => string;
        fileListLabel: string;
        constraintsAccept: (accept: string) => string;
        constraintsMaxSize: (size: string) => string;
        constraintsMaxFiles: (count: number) => string;
        rejectionType: (name: string) => string;
        rejectionSize: (name: string, max: string) => string;
        rejectionCount: (max: number) => string;
        bytesUnit: {
            b: string;
            kb: string;
            mb: string;
            gb: string;
            tb: string;
        };
    };
    input: {
        showPassword: string;
        hidePassword: string;
        clear: string;
    };
    menu: {
        label: string;
    };
    multiSelect: {
        dialogLabel: string;
        placeholder: string;
        searchPlaceholder: string;
        searchEmpty: string;
        selectAll: string;
        clearAll: string;
        removeOption: (label: string) => string;
        selectedCount: (count: number) => string;
        create: (text: string) => string;
    };
    paginator: {
        label: string;
        rowsPerPage: string;
        range: (start: string, end: string, total: string) => string;
        previousPage: string;
        nextPage: string;
        page: (page: string) => string;
    };
    progressBar: {
        label: string;
    };
    rangeSlider: {
        lowThumbLabel: string;
        highThumbLabel: string;
    };
    rating: {
        label: string;
        valueLabel: (value: number, max: number) => string;
        clear: string;
    };
    spinner: {
        label: string;
    };
    stepper: {
        stepsLabel: string;
        optional: string;
        stepCompleted: string;
    };
    tag: {
        remove: string;
    };
    timePicker: {
        placeholder: string;
        dialogLabel: string;
        clear: string;
        hoursLabel: string;
        minutesLabel: string;
        secondsLabel: string;
        incrementHours: string;
        decrementHours: string;
        incrementMinutes: string;
        decrementMinutes: string;
        incrementSeconds: string;
        decrementSeconds: string;
        amLabel: string;
        pmLabel: string;
    };
    toast: {
        dismiss: string;
    };
    transferList: {
        sourceLabel: string;
        targetLabel: string;
        controlsLabel: string;
        moveSelectedToTarget: string;
        moveAllToTarget: string;
        moveSelectedToSource: string;
        moveAllToSource: string;
        empty: string;
        moved: (count: string, listLabel: string) => string;
    };
    validation: {
        required: string;
        email: string;
        min: (min: number) => string;
        max: (max: number) => string;
        minlength: (requiredLength: number) => string;
        maxlength: (requiredLength: number) => string;
        pattern: string;
        invalid: string;
    };
    wordmark: {
        overline: string;
        tagline: string;
    };
}
/** A partial set of message overrides, applied per component group. */
type EagamiMessagesOverride = {
    [G in keyof EagamiMessages]?: Partial<EagamiMessages[G]>;
};
/**
 * A self-identifying locale dictionary. Import the ones you need and register
 * them via `provideEagamiUi({ locales: [...] })` so only those ship in your
 * bundle; English is always available without registration.
 */
interface EagamiLocaleBundle {
    locale: EagamiLocale;
    messages: EagamiMessages;
}
/** Lazily resolves a locale's dictionary, typically via a dynamic `import()`. */
type EagamiLocaleLoader = () => Promise<EagamiLocaleBundle>;
/** Configuration accepted by `provideEagamiUi()`. */
interface EagamiI18nConfig {
    /** Initial locale. Defaults to `'en'`. Falls back to English if not registered. */
    locale?: EagamiLocale;
    /**
     * Locale dictionaries to make available at runtime, beyond the built-in
     * English. Pass `EAGAMI_ALL_LOCALES` for every shipped language, or a subset
     * to keep your bundle lean.
     */
    locales?: readonly EagamiLocaleBundle[];
    /**
     * Lazy loaders for locale dictionaries, keyed by locale. A locale with a
     * loader stays out of the initial bundle and is fetched the first time it
     * is activated via `setLocale()` (or preloaded via `loadLocale()`). Point
     * each loader at a module that re-exports a single locale bundle so the
     * bundler emits one chunk per locale.
     */
    localeLoaders?: Partial<Record<EagamiLocale, EagamiLocaleLoader>>;
    /** Optional per-string overrides merged over the active locale's messages. */
    messages?: EagamiMessagesOverride;
}

/** Public types for the eagami palette provider API. */
/** The 10 derived shade positions, matching the library's existing scale. */
type PaletteShade = '50' | '100' | '200' | '300' | '400' | '500' | '600' | '700' | '800' | '900';
/**
 * Which shade backs each semantic role. Defaults match the library's
 * hand-tuned palette so passing only `base` produces behaviour
 * indistinguishable from the un-themed library.
 */
interface PaletteRoles {
    /** `--color-brand-default` in light mode. */
    surfaceLight: PaletteShade;
    /** `--color-brand-default` in dark mode. */
    surfaceDark: PaletteShade;
    /** `--color-brand-hover` in light mode. */
    surfaceHoverLight: PaletteShade;
    /** `--color-brand-hover` in dark mode. */
    surfaceHoverDark: PaletteShade;
    /** `--color-brand-active` in light mode. */
    surfaceActiveLight: PaletteShade;
    /** `--color-brand-active` in dark mode. */
    surfaceActiveDark: PaletteShade;
    /** `--color-brand-text` in light mode. */
    textLight: PaletteShade;
    /** `--color-brand-text` in dark mode. */
    textDark: PaletteShade;
    /** `--color-brand-subtle` in light mode. */
    subtleLight: PaletteShade;
    /** `--color-brand-muted` in light mode. */
    mutedLight: PaletteShade;
    /** The shade washed at a tenth and a fifth for `--color-brand-subtle` and `--color-brand-muted` in dark mode. */
    tintDark: PaletteShade;
}
declare const DEFAULT_PALETTE_ROLES: PaletteRoles;
interface PaletteConfig {
    /** Anchor hex (`#RRGGBB`). The library derives the full 50–900 scale from
     * this point in OKLCH space, holding hue and chroma roughly constant while
     * stepping lightness. */
    base: string;
    /** Pin individual shades to specific hex values, bypassing derivation for
     * those slots. */
    overrides?: Partial<Record<PaletteShade, string>>;
    /** Remap semantic roles onto different shades. Most consumers leave this
     * unset and accept the defaults. */
    roles?: Partial<PaletteRoles>;
}
/** Top-level palette config accepted by `provideEagamiUi()`. */
interface EagamiPaletteConfig {
    primary?: PaletteConfig;
    secondary?: PaletteConfig;
}
/** Flat CSS-custom-property name to value map for a single mode. */
type DerivedPalette = Record<string, string>;
/**
 * Output of `derivePalette`. Carries a separate map per mode so tokens that
 * have to track the canvas (brand-text, brand-subtle, brand-muted) can hold
 * different values in light and dark, while surface roles stay shared.
 */
interface ModePalette {
    light: DerivedPalette;
    dark: DerivedPalette;
}

/**
 * Full provider configuration for `provideEagamiUi()`. Extends the i18n config
 * with an optional brand palette; omit `palette` to keep the un-themed SCSS
 * defaults.
 */
interface EagamiUiConfig extends EagamiI18nConfig {
    /**
     * Brand palette config. The library derives a 10-shade scale via OKLCH
     * from each base hex, then asserts WCAG AA contrast on every brand-role
     * pairing. A contrast violation throws at bootstrap.
     */
    palette?: EagamiPaletteConfig;
}
/**
 * Configures Eagami UI for the application.
 *
 * ```ts
 * import { frFR, provideEagamiUi } from '@eagami/ui';
 *
 * bootstrapApplication(AppComponent, {
 *   providers: [
 *     provideEagamiUi({
 *       locale: 'fr-FR',
 *       locales: [frFR],
 *       palette: { primary: { base: '#3674a1' } },
 *     }),
 *   ],
 * });
 * ```
 *
 * Optional. Without it, the library defaults to English and ships its
 * built-in brand colours. Only English is bundled until you register more
 * languages via `locales` (pass `EAGAMI_ALL_LOCALES` for all of them), or
 * keep them out of the initial bundle entirely with `localeLoaders`:
 *
 * ```ts
 * provideEagamiUi({
 *   localeLoaders: {
 *     'fr-FR': () => import('./i18n/fr-FR').then(m => m.frFR),
 *   },
 * });
 * ```
 *
 * A `palette` installs a `<style>` tag at bootstrap, carrying Angular's
 * `CSP_NONCE` when the app provides one, so a strict `style-src` policy admits
 * it instead of dropping the theme.
 */
declare function provideEagamiUi(config?: EagamiUiConfig): EnvironmentProviders;

/** DI token carrying the consumer-supplied i18n configuration. */
declare const EAGAMI_I18N_CONFIG: InjectionToken<EagamiI18nConfig>;

/**
 * Holds the active locale and resolves the matching message dictionary for
 * every Eagami UI component. English is always available; other languages are
 * either registered eagerly via `provideEagamiUi({ locales })` or fetched on
 * demand via `provideEagamiUi({ localeLoaders })`. The `locale` signal is
 * reactive, so changing it at runtime re-renders all components. Unknown or
 * unregistered locales fall back to English.
 */
declare class EagamiI18nService {
    private readonly config;
    private readonly registered;
    private readonly loading;
    private pendingSwitch;
    private readonly _locale;
    /** The currently active locale. Read it reactively or call `setLocale()`. */
    readonly locale: Signal<EagamiLocale>;
    constructor();
    /** The resolved message dictionary for the active locale. */
    readonly messages: Signal<EagamiMessages>;
    /**
     * Switches the active locale. A registered locale applies synchronously; a
     * locale with a lazy loader is fetched first, then applied, with the newest
     * request superseding any in-flight one. Falls back to English when the
     * locale is neither registered nor loadable, or when its loader fails.
     * Resolves once the switch has been applied (or superseded).
     */
    setLocale(locale: EagamiLocale): Promise<void>;
    /**
     * Fetches and registers a locale's dictionary through its configured loader
     * without switching to it, so a later `setLocale()` applies instantly.
     * Resolves immediately when the locale is already registered or has no
     * loader. Rejects when the loader fails; the failure is not cached, so a
     * retry fetches again.
     */
    loadLocale(locale: EagamiLocale): Promise<void>;
    private hasLoader;
    private resolveInitialLocale;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EagamiI18nService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
}

declare const ar: EagamiLocaleBundle;

declare const de: EagamiLocaleBundle;

declare const el: EagamiLocaleBundle;

declare const en: EagamiLocaleBundle;

declare const esES: EagamiLocaleBundle;

declare const frFR: EagamiLocaleBundle;

declare const he: EagamiLocaleBundle;

declare const hi: EagamiLocaleBundle;

declare const is: EagamiLocaleBundle;

declare const nl: EagamiLocaleBundle;

declare const pl: EagamiLocaleBundle;

declare const ptBR: EagamiLocaleBundle;

declare const ru: EagamiLocaleBundle;

declare const uk: EagamiLocaleBundle;

declare const zhCN: EagamiLocaleBundle;

/**
 * Every built-in locale bundle. Registering this pulls all shipped languages
 * into the bundle; import individual locales instead to keep it lean.
 */
declare const EAGAMI_ALL_LOCALES: readonly EagamiLocaleBundle[];

/**
 * Replaces regular spaces with U+202F (narrow non-breaking space) in the
 * positions where standard French typography requires "espace fine insécable":
 * before `!` `?` `:` `;` `»`, and after `«`. This is what publishers like the
 * Imprimerie nationale and most French press follow, and it prevents the
 * punctuation from wrapping onto its own line.
 *
 * Opt-in: the library does not auto-apply this to anything. Components render
 * whatever string they receive. Apply this to consumer-supplied content (user
 * input, content from your CMS, etc.) that you want to format correctly for a
 * French audience. The function is idempotent: already-converted text passes
 * through unchanged.
 *
 * Do not apply it to URLs, CSS, JSON, code snippets, or other technical
 * strings where `:` or `?` have non-prose meaning.
 *
 * @example
 * frenchSpacing('Lignes par page :');
 * // returns 'Lignes par page\u202F:'
 *
 * frenchSpacing("Qu'est-ce que c'est ?");
 * // returns "Qu'est-ce que c'est\u202F?"
 *
 * frenchSpacing('Il a dit « bonjour ».');
 * // returns 'Il a dit «\u202Fbonjour\u202F».'
 */
declare function frenchSpacing(text: string): string;

declare function derivePalette(config: EagamiPaletteConfig): ModePalette;

interface ContrastViolation {
    /** CSS custom-property name that fails the contrast bar. */
    token: string;
    /** Hex value of that token. */
    value: string;
    /** Hex value of the surface it was checked against. */
    surface: string;
    /** Computed contrast ratio. */
    ratio: number;
    /** Minimum ratio the role required. */
    required: number;
    /** What the role represents (for the error message). */
    role: 'text' | 'large-text' | 'non-text';
    /** Which mode the violation occurred in. */
    mode: 'light' | 'dark';
}
/** One canvas + on-brand text pairing for a single colour mode. */
interface ModeSurfaces {
    /** Page background the brand sits on (`--color-bg-canvas`). */
    canvas: string;
    /** Foreground colour that sits on the brand surface (button label). */
    onBrandText: string;
}
interface ContrastSurfaces {
    light: ModeSurfaces;
    dark: ModeSurfaces;
}
/**
 * Walk every meaningful pairing in a derived palette and return any
 * violations of the WCAG 2.1 AA contrast bars. Empty array means the
 * palette is safe.
 *
 * Each check runs in both light and dark mode so a palette can't pass one
 * mode while silently failing the other.
 *
 * Checks per mode:
 *   - `--color-brand-text` vs `canvas` >= 4.5:1 (link / foreground text)
 *   - `--color-brand-default` vs `onBrandText` >= 4.5:1 (button label)
 *   - `--color-brand-default` vs `canvas` >= 3:1 (WCAG 1.4.11 non-text)
 */
declare function validatePalette(palette: ModePalette, surfaces?: ContrastSurfaces): ContrastViolation[];
/** Format a violation list as a human-readable error message. */
declare function formatViolations(violations: readonly ContrastViolation[]): string;

/**
 * Install the derived palette as a `<style>` tag in `document.head`. Light
 * values land on `:root`; dark values land on `:root[data-theme="dark"]` and
 * inside `@media (prefers-color-scheme: dark) :root:not([data-theme="light"])`,
 * mirroring the library's own SCSS dark-mode selectors so a consumer-supplied
 * palette participates in the same theme toggle.
 *
 * Idempotent: subsequent calls replace the previous stylesheet rather than
 * append, so a theme switcher can re-apply without leaking style tags.
 * No-ops outside a DOM context (SSR).
 *
 * Pass `nonce` under a `style-src` policy that requires one, or the browser
 * drops the stylesheet and the app silently renders the library's own colours.
 * `provideEagamiUi()` forwards Angular's `CSP_NONCE` automatically.
 */
declare function applyPalette(palette: ModePalette, nonce?: string | null): void;

declare function relativeLuminance(hex: string): number;
declare function contrastRatio(hexA: string, hexB: string): number;
/**
 * WCAG 2.1 AA contrast floors: 4.5:1 for body text, 3:1 for ≥ 18pt text
 * (or ≥ 14pt bold), 3:1 for UI components (icons, focus rings, meaningful
 * borders).
 */
declare const WCAG_AA: {
    readonly text: 4.5;
    readonly largeText: 3;
    readonly nonText: 3;
};

/**
 * sRGB to OKLCH conversion. OKLCH is used over HSL so derived palettes keep
 * their chroma at darker shades. Follows Björn Ottosson's matrices,
 * https://bottosson.github.io/posts/oklab/.
 */
interface Oklch {
    /** Lightness, 0–1. */
    l: number;
    /** Chroma, 0 to ~0.4 in sRGB gamut. */
    c: number;
    /** Hue, 0–360 degrees. */
    h: number;
}
declare function hexToOklch(hex: string): Oklch;
declare function oklchToHex(oklch: Oklch): string;

/**
 * Canonical t-shirt size scale shared by every sized component. A component's
 * own size type (e.g. `ButtonSize`) aliases this so the scale is defined once.
 */
type EaSize = '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl';
/**
 * Size scale for width-based components (panels such as drawer and dialog),
 * adding a step above `xl` and a full-bleed option on top of the standard
 * scale. A panel holds layouts (grids, tables) that a control never does, so it
 * runs one step wider before the jump to full.
 */
type EaWidth = EaSize | '2xl' | 'full';

/** Heading level exposed by each item's header for assistive technology. */
type AccordionHeadingLevel = 1 | 2 | 3 | 4 | 5 | 6;
/** Visual size of the accordion, shared by all of its items. */
type AccordionSize = EaSize;
/**
 * Container for expandable content sections. By default only one item can be
 * open at a time; set `multi` to allow several to stay expanded together.
 * Provides a built-in chevron animation and supports per-item disabling.
 */
declare class AccordionComponent {
    readonly multi: _angular_core.InputSignal<boolean>;
    /** Visual size of the accordion; every item inherits it. */
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Heading level (1-6) applied to every item's header wrapper. */
    readonly headingLevel: _angular_core.InputSignal<AccordionHeadingLevel>;
    readonly expandedItems: _angular_core.WritableSignal<Set<string>>;
    toggle(value: string): void;
    isExpanded(value: string): boolean;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionComponent, "ea-accordion", never, { "multi": { "alias": "multi"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/**
 * Single expandable section within an `ea-accordion`. Each item exposes a
 * header button with the supplied `label` and reveals its projected content
 * when expanded. Inherits its size from the parent accordion. Must be
 * rendered inside an `ea-accordion`.
 */
declare class AccordionItemComponent {
    private readonly accordion;
    readonly value: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    readonly isExpanded: _angular_core.Signal<boolean>;
    readonly headingLevel: _angular_core.Signal<_eagami_ui.AccordionHeadingLevel>;
    readonly size: _angular_core.Signal<_eagami_ui.EaSize>;
    toggle(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AccordionItemComponent, "ea-accordion-item", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/** Semantic colour scheme of an alert. Drives icon and palette. */
type AlertVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
/** Scales the alert's text, icon, and gap together. */
type AlertSize = EaSize;
/**
 * Inline banner for surfacing semantic messages such as success confirmations,
 * warnings, or errors. Optionally dismissible, with a two-way `visible`
 * binding and an automatically chosen ARIA role based on severity.
 */
declare class AlertComponent {
    protected readonly i18n: EagamiI18nService;
    readonly variant: _angular_core.InputSignal<AlertVariant>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly dismissible: _angular_core.InputSignal<boolean>;
    readonly visible: _angular_core.ModelSignal<boolean>;
    /** Overrides the variant's default status icon with any icon component. */
    readonly icon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Fires when the user dismisses the alert via its close button. */
    readonly dismissed: _angular_core.OutputEmitterRef<void>;
    readonly alertClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    readonly role: _angular_core.Signal<"alert" | "status">;
    /** Hides the alert and emits `dismissed`. */
    dismiss(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertComponent, "ea-alert", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "dismissible": { "alias": "dismissible"; "required": false; "isSignal": true; }; "visible": { "alias": "visible"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, { "visible": "visibleChange"; "dismissed": "dismissed"; }, never, ["*"], true, never>;
}

/**
 * Common option shape used by single-select form controls
 * (autocomplete, dropdown, segmented).
 */
interface SelectOption {
    value: string;
    label: string;
    disabled?: boolean;
}
/**
 * A section of a select-like option list. A group carrying a `label` renders a
 * non-interactive heading above its options; one without renders as a rule
 * separating it from the section before it.
 */
interface SelectOptionGroup {
    label?: string;
    options: SelectOption[];
}
/** Option list accepted by select-like controls: flat, or split into groups. */
type SelectOptions = readonly SelectOption[] | readonly SelectOptionGroup[];

/** An option paired with its position in the flattened option list. */
interface IndexedOption {
    option: SelectOption;
    index: number;
}
/** A group ready to render, with headings and rules kept out of the index maths. */
interface RenderedGroup {
    label: string | undefined;
    /** Whether a rule renders above this group, in place of a heading. */
    rule: boolean;
    options: IndexedOption[];
}
/** Whether the consumer supplied groups rather than a flat option list. */
declare function isGrouped(options: SelectOptions): options is readonly SelectOptionGroup[];

/** Visual size of the autocomplete input. */
type AutocompleteSize = EaSize;
/**
 * Text input paired with a filtered suggestion list. Filters options by
 * case-insensitive substring match, supports arrow-key navigation, and
 * implements `ControlValueAccessor` for use with reactive and template-driven
 * forms.
 */
declare class AutocompleteComponent implements ControlValueAccessor {
    private readonly inputEl;
    private readonly i18n;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Accessible name for the input and suggestion list when no visible label is provided. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly placeholder: _angular_core.InputSignal<string>;
    /** Selectable options, either flat or split into groups. */
    readonly options: _angular_core.InputSignal<SelectOptions>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly minLength: _angular_core.InputSignal<number>;
    readonly maxResults: _angular_core.InputSignal<number>;
    readonly emptyMessage: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<string>;
    /** Fires when the user picks an option from the suggestion list. */
    readonly selected: _angular_core.OutputEmitterRef<SelectOption>;
    /** Fires whenever the input text changes, including on free-text edits. */
    readonly changed: _angular_core.OutputEmitterRef<string>;
    /** Fires when the input receives focus. */
    readonly focused: _angular_core.OutputEmitterRef<FocusEvent>;
    /** Fires when the input loses focus. */
    readonly blurred: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    readonly isFocused: _angular_core.WritableSignal<boolean>;
    readonly focusedIndex: _angular_core.WritableSignal<number>;
    private readonly _formDisabled;
    private justSelected;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    private readonly optionGroups;
    /** Whether the consumer supplied groups, which the list exposes as ARIA groups. */
    protected readonly grouped: _angular_core.Signal<boolean>;
    private readonly filteredGroups;
    readonly filteredOptions: _angular_core.Signal<SelectOption[]>;
    /** Groups to render, each option carrying its index into `filteredOptions`. */
    protected readonly renderedGroups: _angular_core.Signal<RenderedGroup[]>;
    protected readonly selectedIndex: _angular_core.Signal<number>;
    readonly showList: _angular_core.Signal<boolean>;
    readonly showEmpty: _angular_core.Signal<boolean>;
    /** Empty-list message, falling back to the active locale's translation. */
    readonly resolvedEmptyMessage: _angular_core.Signal<string>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-autocomplete__wrapper--error': boolean;
        'ea-autocomplete__wrapper--focused': boolean;
        'ea-autocomplete__wrapper--readonly': boolean;
        'ea-autocomplete__wrapper--disabled': boolean;
    }>;
    readonly listboxClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleInput(event: Event): void;
    handleFocus(event: FocusEvent): void;
    handleBlur(event: FocusEvent): void;
    handleKeydown(event: KeyboardEvent): void;
    /** Programmatically selects the given option, updating the value and closing the list. */
    selectOption(option: SelectOption): void;
    /** Closes the suggestion list without changing the current value. */
    close(): void;
    /** Moves keyboard focus to the underlying text input. */
    focus(): void;
    private moveFocus;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AutocompleteComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AutocompleteComponent, "ea-autocomplete", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "maxResults": { "alias": "maxResults"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "selected": "selected"; "changed": "changed"; "focused": "focused"; "blurred": "blurred"; }, never, ["[slot=prefix]", "[slot=suffix]"], true, never>;
}

/** Crop mask shape applied to the exported image. */
type AvatarEditorShape = 'circle' | 'square';
/** Result of a successful crop, providing both a `Blob` and a data URL. */
interface AvatarEditorCropEvent {
    blob: Blob;
    dataUrl: string;
}
/** Persisted pan/zoom state, suitable for restoring an in-progress edit. */
interface AvatarEditorCropState {
    zoom: number;
    offsetX: number;
    offsetY: number;
}
/**
 * Canvas-based image editor for cropping avatars. Supports drag-and-drop
 * upload, mouse/touch panning, zoom via slider or scroll wheel, and exports
 * the cropped image as either a `Blob` or a data URL.
 */
declare class AvatarEditorComponent implements OnDestroy {
    readonly canvasEl: _angular_core.Signal<ElementRef<HTMLCanvasElement> | undefined>;
    readonly fileInputEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    protected readonly i18n: EagamiI18nService;
    readonly shape: _angular_core.InputSignal<AvatarEditorShape>;
    readonly canvasSize: _angular_core.InputSignal<number>;
    readonly currentSrc: _angular_core.InputSignal<string | undefined>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly accept: _angular_core.InputSignal<string>;
    readonly maxFileSize: _angular_core.InputSignal<number>;
    readonly minZoom: _angular_core.InputSignal<number>;
    readonly maxZoom: _angular_core.InputSignal<number>;
    readonly exportQuality: _angular_core.InputSignal<number>;
    readonly exportType: _angular_core.InputSignal<string>;
    readonly cropState: _angular_core.InputSignal<AvatarEditorCropState | null | undefined>;
    /** Fires when the user finalises a crop via {@link exportCrop}; payload contains both `Blob` and data URL. */
    readonly cropped: _angular_core.OutputEmitterRef<AvatarEditorCropEvent>;
    /** Fires when a file is chosen from disk or dropped onto the editor. */
    readonly fileSelected: _angular_core.OutputEmitterRef<File>;
    /** Fires when the current image is cleared via the remove control. */
    readonly removed: _angular_core.OutputEmitterRef<void>;
    /** Fires with a human-readable message when validation fails (wrong type, oversized file, etc.). */
    readonly errored: _angular_core.OutputEmitterRef<string>;
    /** Fires whenever the user pans or zooms the image; useful for persisting in-progress crops. */
    readonly cropStateChanged: _angular_core.OutputEmitterRef<AvatarEditorCropState>;
    readonly instructionsId: string;
    readonly hasImage: _angular_core.WritableSignal<boolean>;
    readonly lastError: _angular_core.WritableSignal<string | null>;
    readonly isDragOver: _angular_core.WritableSignal<boolean>;
    readonly isAtOriginal: _angular_core.WritableSignal<boolean>;
    readonly isLoading: _angular_core.Signal<boolean>;
    readonly zoom: _angular_core.WritableSignal<number>;
    readonly canRevert: _angular_core.Signal<boolean>;
    /** True when the visible crop is darker than mid-grey; drives the `--on-light` class on the overlay so the "Change photo" affordance stays readable. */
    readonly isImageDark: _angular_core.WritableSignal<boolean>;
    private image;
    private offsetX;
    private offsetY;
    private dragStartX;
    private dragStartY;
    private isDragging;
    private hasDragged;
    private initialOffsetX;
    private initialOffsetY;
    private _suppressCropStateEmit;
    private readonly isFetching;
    private readonly originalCaptured;
    private originalImage;
    private originalCropState;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-avatar-editor--has-image': boolean;
        'ea-avatar-editor--drag-over': boolean;
    }>;
    private readonly injector;
    private readonly boundWheel;
    constructor();
    ngOnDestroy(): void;
    onDragEnter(event: DragEvent): void;
    onDragOver(event: DragEvent): void;
    private acceptDrag;
    onDragLeave(event: DragEvent): void;
    onDrop(event: DragEvent): void;
    onFileSelected(event: Event): void;
    /** Opens the native file picker dialog. */
    openFilePicker(): void;
    onMouseDown(event: MouseEvent): void;
    onTouchStart(event: TouchEvent): void;
    private readonly onMouseMoveBound;
    private readonly onMouseUpBound;
    private readonly onTouchMoveBound;
    private readonly onTouchEndBound;
    private onMouseMove;
    private onMouseUp;
    private onTouchMove;
    private onTouchEnd;
    private onWheel;
    onCanvasKeydown(event: KeyboardEvent): void;
    /** Sets the zoom level, clamped to the configured `minZoom`/`maxZoom` range. */
    setZoom(value: number): void;
    onZoomInput(event: Event): void;
    /** Clears the loaded image and resets pan/zoom to defaults. */
    removeImage(): void;
    private syncAtOriginal;
    /** Marks the current image and crop state as the baseline for {@link revertImage}. */
    captureOriginal(): void;
    /** Restores the image and crop state captured by the most recent {@link captureOriginal}. */
    revertImage(): void;
    /** Renders the current crop to an offscreen canvas, emits `cropped`, and resolves with the resulting `Blob`. */
    exportCrop(): Promise<Blob>;
    private loadFromUrl;
    private loadFile;
    private scheduleDrawAfterRender;
    private drawLoadedImage;
    private centerImage;
    private getScale;
    private getDrawParams;
    private applyZoom;
    private clampOffset;
    private draw;
    /**
     * Samples the visible crop region and stores whether it's darker than
     * mid-grey, so the hover overlay can flip its label and icon between
     * white (on dark photos) and black (on light photos).
     *
     * Restricts sampling to the inscribed circle for circle crops to ignore
     * the soon-to-be-masked corners. Uses Rec. 601 perceptual luminance
     * weights; transparent pixels and CORS-tainted canvases default to a
     * "dark" assumption (white ink).
     */
    private updateImageDarkness;
    private emitCropStateChange;
    private clearCanvas;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarEditorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarEditorComponent, "ea-avatar-editor", never, { "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "canvasSize": { "alias": "canvasSize"; "required": false; "isSignal": true; }; "currentSrc": { "alias": "currentSrc"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; "isSignal": true; }; "minZoom": { "alias": "minZoom"; "required": false; "isSignal": true; }; "maxZoom": { "alias": "maxZoom"; "required": false; "isSignal": true; }; "exportQuality": { "alias": "exportQuality"; "required": false; "isSignal": true; }; "exportType": { "alias": "exportType"; "required": false; "isSignal": true; }; "cropState": { "alias": "cropState"; "required": false; "isSignal": true; }; }, { "cropped": "cropped"; "fileSelected": "fileSelected"; "removed": "removed"; "errored": "errored"; "cropStateChanged": "cropStateChanged"; }, never, never, true, never>;
}

/** Diameter (or side length) preset for an avatar. */
type AvatarSize = EaSize;
/** Outline of the avatar: round or rounded-square. */
type AvatarShape = 'circle' | 'square';
/**
 * Compact image used to represent a user or entity. Falls back to initials
 * when no `src` is provided, then to a generic user icon when neither image
 * nor initials are available.
 */
declare class AvatarComponent {
    readonly src: _angular_core.InputSignal<string | undefined>;
    readonly alt: _angular_core.InputSignal<string>;
    readonly initials: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly shape: _angular_core.InputSignal<AvatarShape>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    readonly accessibleName: _angular_core.Signal<string | null>;
    readonly showImage: _angular_core.Signal<boolean>;
    readonly showInitials: _angular_core.Signal<boolean>;
    readonly showFallback: _angular_core.Signal<boolean>;
    handleImageError(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AvatarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AvatarComponent, "ea-avatar", never, { "src": { "alias": "src"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "initials": { "alias": "initials"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Semantic colour scheme of a badge. */
type BadgeVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
/** Visual size of a badge. */
/**
 * The badge ladder sits one step below the shared scale (its `xs` is already
 * `--font-size-2xs`), so it bottoms out where the others gain a `2xs`.
 */
type BadgeSize = Exclude<EaSize, '2xs'>;
/**
 * Outer shape of a badge.
 * - `pill` (default): content-shaped pill, ideal for inline status labels
 * - `pin`: fixed-min square that renders as a perfect circle for single
 *   characters (counts) and expands into a pill for longer content
 */
type BadgeShape = 'pill' | 'pin';
/**
 * Compact indicator used to communicate status, counts, or labels inline with
 * surrounding content.
 */
declare class BadgeComponent {
    readonly variant: _angular_core.InputSignal<BadgeVariant>;
    readonly size: _angular_core.InputSignal<BadgeSize>;
    readonly shape: _angular_core.InputSignal<BadgeShape>;
    readonly uppercase: _angular_core.InputSignal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-badge--uppercase': boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeComponent, "ea-badge", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "uppercase": { "alias": "uppercase"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/** Visual style of the separator rendered between breadcrumb items. */
type BreadcrumbsSeparator = 'chevron' | 'slash';
/** Visual size of the breadcrumb trail. */
type BreadcrumbsSize = EaSize;
/** Single entry in a breadcrumb trail. */
interface BreadcrumbItem {
    label: string;
    href?: string;
    disabled?: boolean;
}
/** Payload emitted when a breadcrumb is activated. */
interface BreadcrumbClickEvent {
    item: BreadcrumbItem;
    index: number;
    event: MouseEvent;
}
/**
 * Navigation trail that shows the user's location within a hierarchy. Items
 * with an `href` render as links, others render as buttons; the final item is
 * always treated as the current page and is non-interactive.
 */
declare class BreadcrumbsComponent {
    private readonly i18n;
    readonly items: _angular_core.InputSignal<BreadcrumbItem[]>;
    readonly separator: _angular_core.InputSignal<BreadcrumbsSeparator>;
    /** Visual size of the breadcrumb trail. */
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    /** Fires when a non-disabled, non-final breadcrumb is activated. */
    readonly clicked: _angular_core.OutputEmitterRef<BreadcrumbClickEvent>;
    /** Accessible label for the breadcrumb nav, falling back to the active locale. */
    readonly resolvedAriaLabel: _angular_core.Signal<string>;
    isLast(index: number): boolean;
    handleClick(item: BreadcrumbItem, index: number, event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BreadcrumbsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BreadcrumbsComponent, "ea-breadcrumbs", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, never, true, never>;
}

/** Visual style of a button; drives colour and emphasis. */
type ButtonVariant = 'primary' | 'secondary' | 'ghost' | 'danger';
/** Visual size of a button. */
type ButtonSize = EaSize;
/** HTML `type` attribute applied to the underlying `<button>` element. */
type ButtonType = 'button' | 'submit' | 'reset';
/**
 * Standard action button supporting primary, secondary, ghost, and danger
 * variants. Includes a loading state that swaps the label for a spinner while
 * preserving the rendered width. Chrome is tunable per instance via
 * `--ea-button-padding`, `--ea-button-min-height` and `--ea-button-radius`,
 * which is how an icon-only button comes down to little more than its glyph
 * and how a call-to-action becomes a pill.
 */
declare class ButtonComponent {
    readonly variant: _angular_core.InputSignal<ButtonVariant>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly type: _angular_core.InputSignal<ButtonType>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly loading: _angular_core.InputSignal<boolean>;
    readonly fullWidth: _angular_core.InputSignal<boolean>;
    readonly uppercase: _angular_core.InputSignal<boolean>;
    /** Optional icon component rendered to the left of the label. */
    readonly icon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly ariaCurrent: _angular_core.InputSignal<string | undefined>;
    /** Fires when the button is activated; suppressed while disabled or loading. */
    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-button--full-width': boolean;
        'ea-button--uppercase': boolean;
        'ea-button--loading': boolean;
        'ea-button--disabled': boolean;
    }>;
    handleClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ButtonComponent, "ea-button", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "uppercase": { "alias": "uppercase"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaCurrent": { "alias": "aria-current"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["[slot=prefix]", "*", "[slot=suffix]"], true, never>;
}

/** Visual style of a card surface. */
type CardVariant = 'elevated' | 'outlined' | 'filled';
/** Padding preset applied to the card's content area. */
type CardPadding = 'none' | 'sm' | 'md' | 'lg' | 'xl';
/** Horizontal alignment of card header content. */
type CardHeaderAlign = 'start' | 'center' | 'end';
/**
 * Surface for grouping related content. Provides optional `header` and
 * `footer` content slots and supports elevated, outlined, and filled
 * variants. The card shadow can be customised per instance via the
 * `--ea-card-shadow` CSS custom property.
 */
declare class CardComponent {
    readonly variant: _angular_core.InputSignal<CardVariant>;
    readonly padding: _angular_core.InputSignal<CardPadding>;
    readonly fullWidth: _angular_core.InputSignal<boolean>;
    readonly headerAlign: _angular_core.InputSignal<CardHeaderAlign>;
    readonly headerDivider: _angular_core.InputSignal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-card--full-width': boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CardComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CardComponent, "ea-card", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "padding": { "alias": "padding"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "headerAlign": { "alias": "headerAlign"; "required": false; "isSignal": true; }; "headerDivider": { "alias": "headerDivider"; "required": false; "isSignal": true; }; }, {}, never, ["[slot=header]", "*", "[slot=footer]"], true, never>;
}

/** Visual size of a checkbox. */
type CheckboxSize = EaSize;
/**
 * Boolean form control with support for an indeterminate visual state. Pairs
 * a visually hidden native input with a custom checkmark and integrates with
 * Angular forms via `ControlValueAccessor`.
 */
declare class CheckboxComponent implements ControlValueAccessor {
    readonly label: _angular_core.InputSignal<string | undefined>;
    /**
     * Optional supplementary value shown immediately after the label, dimmed
     * to the tertiary text token. Renders inside the same `<span>` as the
     * label so it shares the label's exact baseline and font metrics, keeping
     * "Inbox 42" / "Brand (30)" patterns aligned without a sibling element
     * fighting flex / inline-flow centring at the consumer's call site.
     */
    readonly count: _angular_core.InputSignal<string | number | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    /**
     * Ellipsize a label too long for the space the checkbox is given, revealing
     * the full text in a tooltip while it is clipped. Off by default, since a
     * checkbox otherwise widens its column rather than hiding any of its label.
     */
    readonly truncate: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly indeterminate: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly checked: _angular_core.ModelSignal<boolean>;
    /** Fires with the new checked state whenever the user toggles the checkbox. */
    readonly changed: _angular_core.OutputEmitterRef<boolean>;
    private readonly _formDisabled;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    /** What a clamped label reveals: the count rides along, since the ellipsis takes it first. */
    protected readonly clampedText: _angular_core.Signal<string>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-checkbox--truncate': boolean;
        'ea-checkbox--disabled': boolean;
        'ea-checkbox--checked': boolean;
        'ea-checkbox--indeterminate': boolean;
        'ea-checkbox--error': boolean;
    }>;
    private onChange;
    private onTouched;
    writeValue(val: boolean): void;
    registerOnChange(fn: (value: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleKeydown(event: KeyboardEvent): void;
    handleChange(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckboxComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckboxComponent, "ea-checkbox", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "changed": "changed"; }, never, never, true, never>;
}

/**
 * Primary classification for an icon component. Every icon ships with a single
 * `category` (read off the component's `static readonly category` field) plus
 * a separate `static readonly isBrand` flag for whether it also depicts a
 * recognisable brand mark.
 *
 * `feather`: derived from the upstream Feather Icons set (MIT). Uses Feather's
 *            canonical slug and design.
 * `eagami`:  Eagami UI additions beyond the Feather set: the brand mark, the
 *            basic shape set and household icons, brand-filled variants of
 *            Feather outlines, the coloured brand marks (`isBrand`), and line
 *            icons adapted from Lucide (ISC).
 */
type IconCategory = 'feather' | 'eagami';
/**
 * Shape of the static metadata that every `ea-icon-*` component carries
 * alongside its template. Read these fields directly off the component class
 * (e.g. `GithubIconComponent.tags`) to build catalogues, search indices, or
 * documentation tables without pulling in any other icon as a transitive
 * dependency.
 */
interface IconMeta {
    readonly slug: string;
    readonly category: IconCategory;
    /** True when the icon depicts a recognisable third-party or Eagami brand mark. */
    readonly isBrand?: boolean;
    readonly tags: ReadonlyArray<string>;
}
/** An icon component class augmented with its static metadata. */
type IconComponentType = Type<unknown> & IconMeta;
/**
 * Abstract base class for every `ea-icon-*` component. Provides the shared
 * host bindings that make icons render as inline-flex 1em squares, so
 * individual icon components don't need to repeat the `host: { style: '...' }`
 * config in their `@Component` decorator. Brand icons with their own host
 * bindings (e.g. a colour binding tied to a `brand` input) layer those onto
 * this base via additional `@HostBinding` getters.
 *
 * Feather-derived icons read the `strokeWidth` input via `[attr.stroke-width]`
 * in their SVG template, so consumers can thin or thicken any icon at the
 * call site (e.g. `<ea-icon-star [strokeWidth]="1.5" />`). Subclasses can
 * change the default by setting `static override readonly defaultStrokeWidth`,
 * used by icons whose dense paths read better at a different default
 * (e.g. camera, upload at 1.5).
 */
declare abstract class IconComponentBase {
    readonly display = "inline-flex";
    readonly width = "1em";
    readonly height = "1em";
    static readonly defaultStrokeWidth: number;
    readonly strokeWidth: _angular_core.InputSignal<number>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<IconComponentBase, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<IconComponentBase, never, never, { "strokeWidth": { "alias": "strokeWidth"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SearchIconComponent extends IconComponentBase {
    static readonly slug = "search";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SearchIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SearchIconComponent, "ea-icon-search", never, {}, {}, never, never, true, never>;
}

/**
 * A single executable command in an `<ea-command-palette>`.
 *
 * The filter matches on `label`, `description`, and `keywords` (all
 * case-insensitive). Keywords are invisible synonyms, e.g. label "Sign out"
 * with keywords `['logout', 'log out']` so the command surfaces under any
 * spelling the user knows.
 */
interface CommandPaletteItem<T = unknown> {
    /** Stable id used for tracking and `aria-activedescendant`. */
    id: string;
    /** Visible label rendered for the command. */
    label: string;
    /** Optional secondary text rendered below the label. */
    description?: string;
    /** Optional leading icon component (e.g. `SearchIconComponent`). */
    icon?: Type<unknown>;
    /**
     * Optional keyboard-shortcut hint rendered on the right edge of the row.
     * Decorative: the palette does not bind global shortcuts, the consumer
     * does that.
     */
    shortcut?: string;
    /** Section heading the command groups under. Items without a group render first. */
    group?: string;
    /** When true, the row is greyed out and cannot be activated. */
    disabled?: boolean;
    /** Extra hidden search terms. */
    keywords?: readonly string[];
    /** Arbitrary payload passed through to `(execute)`. */
    data?: T;
}

interface PaletteEntry {
    item: CommandPaletteItem;
    flatIndex: number;
    disabled: boolean;
}
interface GroupedItems {
    group: string;
    items: readonly PaletteEntry[];
}
/**
 * `<ea-command-palette>` is a search-driven action launcher: a modal dialog
 * containing a search input and a filtered list of commands. Designed for
 * `Cmd/Ctrl + K`-style global menus.
 *
 * The component does NOT bind global shortcuts; the consumer wires up
 * whatever trigger they want and toggles `[(open)]`. Each selected command
 * is emitted via `(execute)`; the palette closes automatically afterwards.
 *
 * Items can be grouped via the `group` field; ungrouped items render first.
 * The active row is tracked via roving `aria-activedescendant` on the search
 * input, which is the canonical ARIA combobox-with-listbox pattern.
 */
declare class CommandPaletteComponent {
    private readonly i18n;
    private readonly hostEl;
    private readonly press;
    readonly items: _angular_core.InputSignal<readonly CommandPaletteItem<unknown>[]>;
    readonly open: _angular_core.ModelSignal<boolean>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly emptyMessage: _angular_core.InputSignal<string>;
    /**
     * Optional predicate that disables every item it returns `true` for, in
     * addition to each item's own `disabled` flag.
     */
    readonly disabledWhen: _angular_core.InputSignal<((item: CommandPaletteItem) => boolean) | undefined>;
    readonly execute: _angular_core.OutputEmitterRef<CommandPaletteItem<unknown>>;
    protected readonly messages: _angular_core.Signal<_eagami_ui.EagamiMessages>;
    protected readonly resolvedPlaceholder: _angular_core.Signal<string>;
    private readonly dialogEl;
    private readonly searchEl;
    protected readonly searchIcon: typeof SearchIconComponent;
    protected readonly query: _angular_core.WritableSignal<string>;
    protected readonly listboxId: string;
    /**
     * Items bucketed by `group`, then flattened back into display order
     * (ungrouped items first, then each named group). The matching
     * `filteredEntries` array follows this same order so `flatIndex` lines up
     * one-to-one with what the user sees. Each entry resolves its disabled state
     * once here, so a consumer's `disabledWhen` runs once per match rather than
     * on every binding read.
     */
    protected readonly groupedItems: _angular_core.Signal<GroupedItems[]>;
    /**
     * Flat list of matches in display order. Drives keyboard navigation and
     * `aria-activedescendant`.
     */
    protected readonly filteredEntries: _angular_core.Signal<PaletteEntry[]>;
    private readonly _activeIndex;
    /**
     * Tracks what the user last did so the visual highlight only renders when
     * it actually reflects what a click/Enter would select right now:
     *  - `keyboard`: keyboard nav (or just-opened / just-typed): show the
     *    active item's background so keyboard users see what Enter will pick.
     *  - `mouse`: pointer is moving inside the list: rely on `:hover` for the
     *    visual; skip the active-row background to avoid two highlights.
     *  - `none`: pointer is outside the list and no keyboard nav has happened
     *    since: nothing is highlighted, because nothing on screen is a
     *    next-click target.
     */
    private readonly interaction;
    protected readonly activeIndex: _angular_core.Signal<number>;
    protected readonly activeId: _angular_core.Signal<string | undefined>;
    constructor();
    protected itemDomId(item: CommandPaletteItem): string;
    /** Index of the first enabled entry from `start`, walking in `step`; -1 when none. */
    private firstEnabled;
    protected isActive(flatIndex: number): boolean;
    /**
     * Whether the active row should render its highlighted background right
     * now. False when the pointer is hovering the list (`:hover` handles the
     * visual) or when the pointer is out of the list entirely (nothing is a
     * next-click target).
     */
    protected showActiveHighlight(flatIndex: number): boolean;
    protected onQueryChange(value: string): void;
    protected onSearchKeydown(event: KeyboardEvent): void;
    /** Wrapping arrow-key move that skips disabled items. */
    private moveActive;
    /** Home/End move to the first enabled item from the given end. */
    private edgeActive;
    private setActiveByKeyboard;
    protected onItemClick(entry: PaletteEntry): void;
    protected onItemMouseEnter(entry: PaletteEntry): void;
    protected onListMouseLeave(): void;
    protected onBackdropClick(event: MouseEvent): void;
    protected onDialogClose(): void;
    private executeItem;
    private scrollActiveIntoView;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandPaletteComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandPaletteComponent, "ea-command-palette", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; "isSignal": true; }; "disabledWhen": { "alias": "disabledWhen"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "execute": "execute"; }, never, never, true, never>;
}

/** Visual size of the color picker trigger. */
type ColorPickerSize = EaSize;
/** Output format. `all` (default) lets the user cycle hex/rgb/hsl from the popover; a specific value locks the picker to it. */
type ColorPickerFormat = 'hex' | 'rgb' | 'hsl' | 'all';
/** A concrete format the popover can show inputs for and emit. */
type ColorPickerInputMode = 'hex' | 'rgb' | 'hsl';
/** Value accepted via `writeValue`: any CSS color string or `null`. */
type ColorPickerValue = string | null;
interface Rgb {
    r: number;
    g: number;
    b: number;
}
/**
 * Popover color picker with a saturation/value gradient area, hue slider,
 * optional alpha slider, hex + RGB inputs, a configurable preset palette,
 * and an eyedropper (Chromium browsers). Integrates with Angular forms via
 * `ControlValueAccessor`. Accepts any CSS color string in `writeValue`.
 */
declare class ColorPickerComponent implements ControlValueAccessor {
    protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLButtonElement> | undefined>;
    private readonly svAreaEl;
    private readonly hueTrackEl;
    private readonly alphaTrackEl;
    private readonly injector;
    protected readonly i18n: EagamiI18nService;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Whether to show the alpha slider. When `false` the emitted value always has alpha = 1. */
    readonly showAlpha: _angular_core.InputSignal<boolean>;
    /** Whether to show the clear button when a value is set. */
    readonly clearable: _angular_core.InputSignal<boolean>;
    /**
     * Trigger as a bare square swatch instead of a field with the value beside
     * it, for a colour sitting in a dense row or a toolbar. The value text and
     * the clear button, which have nowhere to go at that size, are dropped.
     */
    readonly compact: _angular_core.InputSignal<boolean>;
    /** Output format. `all` lets the user cycle hex/rgb/hsl in the popover; a specific value locks it. */
    readonly format: _angular_core.InputSignal<ColorPickerFormat>;
    /** Preset swatches shown at the bottom of the popover. Pass an empty array to hide. */
    readonly presets: _angular_core.InputSignal<readonly string[]>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<string | null>;
    /** Fires with the new color string whenever the selection changes. */
    readonly changed: _angular_core.OutputEmitterRef<string | null>;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    private readonly hue;
    private readonly sat;
    private readonly val;
    private readonly alpha;
    /** Tracks the active drag target so pointermove can route correctly. */
    private readonly dragging;
    /** The user's chosen format when `format` is `all`; the popover toggle cycles it. */
    readonly inputMode: _angular_core.WritableSignal<ColorPickerInputMode>;
    /** Resolved format driving both the visible inputs and the emitted value. */
    readonly activeFormat: _angular_core.Signal<ColorPickerInputMode>;
    /** Whether the in-popover format toggle is shown (only when `format` is `all`). */
    readonly canToggleFormat: _angular_core.Signal<boolean>;
    /** What the hex input shows. Kept separate from the canonical hex so the user
     * can type a partial value (`#1`, `#12`, `#123`...) without each keystroke being
     * expanded back into a 6-digit canonical form. */
    readonly hexInputValue: _angular_core.WritableSignal<string>;
    private readonly _formDisabled;
    /** The last value this component emitted, so the value-sync effect can tell an
     * external `[(value)]` / reset change from its own commit and skip the echo. */
    private lastCommitted;
    private readonly valueSync;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly rgb: _angular_core.Signal<Rgb>;
    /**
     * Presets whose colour matches the current one. Comparing the parsed colour
     * rather than the emitted string keeps the pressed state working in every
     * output format, not only when the value happens to be canonical hex.
     */
    protected readonly activePresets: _angular_core.Signal<Set<string>>;
    readonly displayColor: _angular_core.Signal<string>;
    /** Opaque version of the current color, used as the hue/SV reference. */
    readonly opaqueColor: _angular_core.Signal<string>;
    readonly hueColor: _angular_core.Signal<string>;
    readonly hexDisplay: _angular_core.Signal<string>;
    /** Rounded HSL channels (h in degrees, s/l as percentages) for the HSL inputs. */
    readonly hslDisplay: _angular_core.Signal<{
        h: number;
        s: number;
        l: number;
    }>;
    /** Uppercase label for the format toggle, e.g. `HEX`. */
    readonly formatLabel: _angular_core.Signal<string>;
    /** Accessible name for the format toggle; includes the visible format text. */
    readonly formatToggleLabel: _angular_core.Signal<string>;
    readonly displayValue: _angular_core.Signal<string>;
    readonly resolvedPlaceholder: _angular_core.Signal<string>;
    readonly popoverId: _angular_core.Signal<string>;
    readonly triggerLabelledBy: _angular_core.Signal<string | null>;
    readonly triggerClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-color-picker__trigger--compact': boolean;
        'ea-color-picker__trigger--error': boolean;
        'ea-color-picker__trigger--open': boolean;
        'ea-color-picker__trigger--disabled': boolean;
        'ea-color-picker__trigger--readonly': boolean;
    }>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    readonly popoverClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    /**
     * True when the browser supports the EyeDropper API. Not a `computed`:
     * `window.EyeDropper` isn't a signal, so a memoized computed would cache the
     * first read (typically `false`, since the popover content's bindings
     * evaluate at parent-view creation time via content projection, before any
     * polyfill / test setup runs). A plain method re-checks on every call.
     */
    hasEyeDropper(): boolean;
    writeValue(val: ColorPickerValue): void;
    registerOnChange(fn: (value: string | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    open(): void;
    close(): void;
    focus(): void;
    clear(event: Event): void;
    readonly svPointerLeft: _angular_core.Signal<string>;
    readonly svPointerTop: _angular_core.Signal<string>;
    readonly huePointerLeft: _angular_core.Signal<string>;
    readonly alphaPointerLeft: _angular_core.Signal<string>;
    readonly hueRounded: _angular_core.Signal<number>;
    readonly alphaPercentRounded: _angular_core.Signal<number>;
    readonly satPercent: _angular_core.Signal<number>;
    readonly valPercent: _angular_core.Signal<number>;
    onSvPointerDown(event: PointerEvent): void;
    onSvPointerMove(event: PointerEvent): void;
    onSvPointerUp(event: PointerEvent): void;
    onSvKeydown(event: KeyboardEvent): void;
    private updateSvFromPointer;
    onHuePointerDown(event: PointerEvent): void;
    onHuePointerMove(event: PointerEvent): void;
    onHuePointerUp(event: PointerEvent): void;
    onHueKeydown(event: KeyboardEvent): void;
    private updateHueFromPointer;
    onAlphaPointerDown(event: PointerEvent): void;
    onAlphaPointerMove(event: PointerEvent): void;
    onAlphaPointerUp(event: PointerEvent): void;
    onAlphaKeydown(event: KeyboardEvent): void;
    private updateAlphaFromPointer;
    /**
     * Mirrors the user's literal text into `hexInputValue` and (if the text
     * parses) applies the new color silently, without rewriting the input.
     * Without `refreshHex: false`, typing `#123` would parse, commit, and then
     * snap the input back to `#112233` mid-keystroke, fighting the user's caret.
     * Canonicalization happens only on blur via {@link onHexBlur}.
     */
    onHexInput(event: Event): void;
    onHexBlur(): void;
    onRgbInput(channel: 'r' | 'g' | 'b', event: Event): void;
    onHslInput(channel: 'h' | 's' | 'l', event: Event): void;
    /** Cycles the format through hex, rgb, and hsl (only used when `format` is `all`). */
    cycleInputMode(): void;
    onAlphaInput(event: Event): void;
    pickFromScreen(): Promise<void>;
    selectPreset(hex: string): void;
    onTriggerKeydown(event: KeyboardEvent): void;
    onPopoverKeydown(event: KeyboardEvent): void;
    /** Called by `<ea-popover>` when the user clicks outside the picker. */
    onPopoverCloseRequested(): void;
    private applyHsv;
    private applyRgba;
    private commit;
    private refreshHexInput;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColorPickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColorPickerComponent, "ea-color-picker", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "showAlpha": { "alias": "showAlpha"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "compact": { "alias": "compact"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "presets": { "alias": "presets"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Vertical density preset for table rows and header cells. */
type DataTableDensity = 'compact' | 'comfortable' | 'spacious';
/** Visual size of the table's text, paddings, and icons. */
type DataTableSize = EaSize;
/** Sort direction; `null` means no sort is applied. */
type DataTableSortDirection = 'asc' | 'desc' | null;
/** Column definition for the data table, including optional cell/header templates. */
interface DataTableColumn<T = Record<string, unknown>> {
    key: string;
    label: string;
    sortable?: boolean;
    align?: 'left' | 'center' | 'right';
    width?: string;
    format?: (value: unknown) => string;
    cellTemplate?: TemplateRef<{
        $implicit: T;
        value: unknown;
    }>;
    headerTemplate?: TemplateRef<{
        $implicit: DataTableColumn<T>;
    }>;
}
/** Current sort state: which column is sorted and in which direction. */
interface DataTableSortState {
    column: string;
    direction: DataTableSortDirection;
}
/**
 * Table for tabular data with sortable columns, sticky headers, and density
 * presets. Supports striping, borders, hoverable rows, and custom cell or
 * header templates via `ng-template`. Sort state is exposed as a two-way
 * `model()` binding.
 */
declare class DataTableComponent<T = Record<string, unknown>> {
    private readonly i18n;
    private readonly host;
    private readonly activeCell;
    private static readonly PAGE_JUMP;
    readonly columns: _angular_core.InputSignal<DataTableColumn<T>[]>;
    readonly data: _angular_core.InputSignal<T[]>;
    /**
     * Rows holding each column's widest content. They are laid out but never shown,
     * so column widths come from them rather than from whichever rows are in `data`,
     * and stay put across pages and while data loads. Moot with `stickyHeader`, whose
     * columns share the width equally unless given a `width`.
     */
    readonly sizingRows: _angular_core.InputSignal<T[]>;
    /** Accessible name for the table, announced when it takes focus as a grid. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    /** Visible caption rendered above the table; also names it for assistive technology. */
    readonly caption: _angular_core.InputSignal<string | undefined>;
    readonly trackBy: _angular_core.InputSignal<keyof T | undefined>;
    readonly density: _angular_core.InputSignal<DataTableDensity>;
    /** Visual size of the table; density paddings and icons scale with it. */
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly stickyHeader: _angular_core.InputSignal<boolean>;
    readonly striped: _angular_core.InputSignal<boolean>;
    readonly hoverable: _angular_core.InputSignal<boolean>;
    readonly bordered: _angular_core.InputSignal<boolean>;
    /** Keeps every cell on one line, so a narrow viewport scrolls the table sideways instead of wrapping its text. */
    readonly nowrap: _angular_core.InputSignal<boolean>;
    readonly noDataText: _angular_core.InputSignal<string | undefined>;
    /** Enables grid keyboard navigation: `role="grid"`, roving tabindex, and arrow-key cell movement. */
    readonly navigable: _angular_core.InputSignal<boolean>;
    /** Marks body rows as clickable: shows a pointer cursor and emits `rowActivate` on click or Enter/Space. Independent of `hoverable` and `navigable`. */
    readonly clickable: _angular_core.InputSignal<boolean>;
    /**
     * Gives a row its link target, or `null` for none. Every cell of the row then holds
     * a real link, so the browser shows the target on hover and a modified click opens
     * it elsewhere, while a plain click still emits `rowActivate` for the app to route.
     */
    readonly rowHref: _angular_core.InputSignal<((row: T) => string | null) | undefined>;
    readonly sort: _angular_core.ModelSignal<DataTableSortState>;
    /** Fires whenever the sort column or direction changes via header click. */
    readonly sorted: _angular_core.OutputEmitterRef<DataTableSortState>;
    /** Fires with the row's data when a body row is activated by click or Enter/Space while `clickable` is set. */
    readonly rowActivate: _angular_core.OutputEmitterRef<T>;
    readonly noDataTemplate: _angular_core.Signal<TemplateRef<unknown> | undefined>;
    /** Empty-state text, falling back to the active locale's translation. */
    readonly resolvedNoDataText: _angular_core.Signal<string>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-data-table--sticky': boolean;
        'ea-data-table--striped': boolean;
        'ea-data-table--hoverable': boolean;
        'ea-data-table--bordered': boolean;
        'ea-data-table--nowrap': boolean;
        'ea-data-table--navigable': boolean;
        'ea-data-table--clickable': boolean;
        'ea-data-table--linked': boolean;
    }>;
    constructor();
    readonly sortedData: _angular_core.Signal<T[]>;
    getCellValue(row: T, key: string): unknown;
    onHeaderClick(col: DataTableColumn<T>): void;
    trackByFn(_index: number, item: T): unknown;
    headerTabindex(colIndex: number): number | null;
    onHeaderKeydown(event: Event, col: DataTableColumn<T>): void;
    bodyCellTabindex(row: number, colIndex: number): number | null;
    rowTabindex(): number | null;
    onRowActivate(row: T, event?: Event): void;
    onCellFocus(row: number, col: number): void;
    onGridKeydown(event: KeyboardEvent): void;
    private focusCell;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataTableComponent<any>, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataTableComponent<any>, "ea-data-table", never, { "columns": { "alias": "columns"; "required": true; "isSignal": true; }; "data": { "alias": "data"; "required": true; "isSignal": true; }; "sizingRows": { "alias": "sizingRows"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "caption": { "alias": "caption"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; "isSignal": true; }; "density": { "alias": "density"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; "isSignal": true; }; "striped": { "alias": "striped"; "required": false; "isSignal": true; }; "hoverable": { "alias": "hoverable"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "nowrap": { "alias": "nowrap"; "required": false; "isSignal": true; }; "noDataText": { "alias": "noDataText"; "required": false; "isSignal": true; }; "navigable": { "alias": "navigable"; "required": false; "isSignal": true; }; "clickable": { "alias": "clickable"; "required": false; "isSignal": true; }; "rowHref": { "alias": "rowHref"; "required": false; "isSignal": true; }; "sort": { "alias": "sort"; "required": false; "isSignal": true; }; }, { "sort": "sortChange"; "sorted": "sorted"; "rowActivate": "rowActivate"; }, ["noDataTemplate"], ["ea-paginator"], true, never>;
}

/** Visual size of each digit cell. */
type CodeInputSize = EaSize;
/**
 * Verification code entry made up of one input per digit. Auto-advances on
 * input, supports paste of the full code at once, and integrates with Angular
 * forms via `ControlValueAccessor`.
 */
declare class CodeInputComponent implements ControlValueAccessor {
    readonly digitEls: _angular_core.Signal<readonly ElementRef<HTMLInputElement>[]>;
    protected readonly i18n: EagamiI18nService;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Placeholder text spread one character per cell (cell i shows character i). */
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly length: _angular_core.InputSignal<number>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    /** Allow any non-whitespace character; when false (default) only digits are accepted. */
    readonly allowAllChars: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<string>;
    readonly focusedIndex: _angular_core.WritableSignal<number>;
    private readonly _formDisabled;
    /** Fires with the full code once every digit has been entered. */
    readonly completed: _angular_core.OutputEmitterRef<string>;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly digits: _angular_core.Signal<string[]>;
    readonly placeholders: _angular_core.Signal<string[]>;
    readonly indices: _angular_core.Signal<number[]>;
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleInput(event: Event, index: number): void;
    handleKeydown(event: KeyboardEvent, index: number): void;
    handlePaste(event: ClipboardEvent): void;
    handleFocus(index: number): void;
    handleBlur(): void;
    /** Moves keyboard focus to the next empty digit (or the last one when full). */
    focus(): void;
    private sanitize;
    private focusDigit;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeInputComponent, "ea-code-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "length": { "alias": "length"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "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; }; "allowAllChars": { "alias": "allowAllChars"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "completed": "completed"; }, never, never, true, never>;
}

/** Visual size of the date picker field. */
type DatePickerSize = EaSize;
/** Locale-aware date format used for the displayed value. */
type DatePickerFormat = 'short' | 'medium' | 'long';
/** First day of the week in the calendar grid (0 = Sunday, 1 = Monday). */
type DatePickerWeekStart = 0 | 1;
/** Value accepted via `writeValue`: a `Date`, ISO/parseable string, or `null`. */
type DatePickerValue = Date | string | null;
interface CalendarDay {
    date: Date;
    day: number;
    isCurrentMonth: boolean;
    isToday: boolean;
    isSelected: boolean;
    isDisabled: boolean;
    isFocused: boolean;
}
/**
 * Date field with a calendar popover. The date can be typed straight into the
 * field in any reasonable shape (ISO, all-numeric in the locale's field order,
 * or with a month name) and is rewritten in the configured `format` on commit.
 * Supports `min`/`max` bounds, configurable week start, locale-aware formatting
 * via `Intl.DateTimeFormat`, and full keyboard navigation (arrows,
 * PageUp/PageDown, Home/End, Enter, Escape). Integrates with Angular forms via
 * `ControlValueAccessor`.
 */
declare class DatePickerComponent implements ControlValueAccessor {
    protected readonly fieldEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    protected readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    private readonly injector;
    protected readonly i18n: EagamiI18nService;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Placeholder shown in the field when no date is selected. */
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly minDate: _angular_core.InputSignal<Date | null>;
    readonly maxDate: _angular_core.InputSignal<Date | null>;
    readonly format: _angular_core.InputSignal<DatePickerFormat>;
    readonly weekStartsOn: _angular_core.InputSignal<DatePickerWeekStart>;
    readonly locale: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<Date | null>;
    /** Fires when the selected date changes, including when cleared. */
    readonly changed: _angular_core.OutputEmitterRef<Date | null>;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    readonly viewYear: _angular_core.WritableSignal<number>;
    readonly viewMonth: _angular_core.WritableSignal<number>;
    readonly focusedDate: _angular_core.WritableSignal<Date | null>;
    private readonly _formDisabled;
    private readonly isFocused;
    /** Entry in progress, held verbatim until it is committed or abandoned. */
    private readonly draft;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    /** Locale used for date formatting: explicit `locale` input, else the global locale. */
    readonly effectiveLocale: _angular_core.Signal<string>;
    /** True when the active date locale is a registered locale we ship a bundle
     *  for (no distinct per-instance `locale` override), so the bundled calendar
     *  names apply and the calendar stays localized regardless of the runtime's
     *  `Intl` locale coverage. */
    private readonly bundleCalendarApplies;
    /** Whether the runtime's `Intl` actually has date data for the active locale.
     *  Some browsers ship a reduced ICU that silently falls back to English for
     *  less common locales, so a matching request is not a given. */
    private readonly intlLocalizesEffectiveLocale;
    /** Placeholder text, empty unless a `placeholder` is given. */
    readonly resolvedPlaceholder: _angular_core.Signal<string>;
    /** Accessible name when no `label` is given. */
    protected readonly fallbackLabel: _angular_core.Signal<string>;
    readonly dialogId: _angular_core.Signal<string>;
    readonly fieldClasses: _angular_core.Signal<{
        'ea-date-picker__field--focused': boolean;
        'ea-date-picker__field--error': boolean;
        'ea-date-picker__field--disabled': boolean;
        'ea-date-picker__field--readonly': boolean;
    }>;
    readonly popoverClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    readonly displayValue: _angular_core.Signal<string>;
    /** Field text: the entry in progress while typing, else the formatted value. */
    readonly inputText: _angular_core.Signal<string>;
    readonly monthYearLabel: _angular_core.Signal<string>;
    readonly weekdayLabels: _angular_core.Signal<string[]>;
    readonly weeks: _angular_core.Signal<CalendarDay[][]>;
    writeValue(val: DatePickerValue): void;
    registerOnChange(fn: (value: Date | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    /** Toggles the calendar popover between open and closed. */
    toggle(): void;
    /** Opens the calendar popover and moves focus to the focused day cell. */
    open(): void;
    /** Closes the calendar popover. */
    close(): void;
    private focusFocusedDayCell;
    /** Moves keyboard focus to the date field. */
    focus(): void;
    selectDay(day: CalendarDay): void;
    /** Clears the selected date and emits `changed` with `null`. */
    clear(event: Event): void;
    goToPrevMonth(): void;
    goToNextMonth(): void;
    goToPrevYear(): void;
    goToNextYear(): void;
    /**
     * Moves the roving date into the month now on screen, keeping the day where
     * the month is long enough. Without this the only tabbable day cell stays in
     * the month the user navigated away from, so inside the focus-trapped dialog
     * no day is reachable and the next arrow key snaps the view back.
     */
    private pullFocusIntoView;
    goToToday(): void;
    protected onInput(event: Event): void;
    protected onInputFocus(): void;
    protected onInputBlur(): void;
    protected handleInputKeydown(event: KeyboardEvent): void;
    private commitDraft;
    private applyValue;
    private isOutOfRange;
    handleGridKeydown(event: KeyboardEvent): void;
    /** Called by `<ea-popover>` when the user clicks outside the picker. */
    onPopoverCloseRequested(): void;
    private formatOptions;
    private toDate;
    private startOfDay;
    private isSameDay;
    private addDays;
    private addMonths;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatePickerComponent, "ea-date-picker", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "minDate": { "alias": "minDate"; "required": false; "isSignal": true; }; "maxDate": { "alias": "maxDate"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "weekStartsOn": { "alias": "weekStartsOn"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Width preset of the dialog panel. */
type DialogWidth = EaWidth;
/**
 * Dialog backed by the native `<dialog>` element. Modal by default, using
 * `showModal()` for browser-managed focus trapping with backdrop and Escape
 * dismissal, and holding the page's scrolling for as long as it is up;
 * `modal` false floats it over a page left scrollable instead. It exposes
 * `header`, default, and `footer` content slots, and the `open` state is a
 * two-way `model()` binding.
 *
 * The header is a row that lays its slot content out against the built-in
 * close button, and it applies the h4 type scale to that content, so a heading
 * element projected into it should carry `font: inherit`. Panel chrome is
 * tunable per dialog via `--ea-dialog-inset`, `--ea-dialog-radius`,
 * `--ea-dialog-max-height`, `--ea-dialog-header-padding`,
 * `--ea-dialog-body-padding`, and `--ea-dialog-status-padding`; an
 * edge-to-edge media surface zeroes the inset, radius, and paddings.
 *
 * Specs running under jsdom need `installNativeDialogShim()` from
 * `@eagami/ui/testing` before opening one.
 */
declare class DialogComponent implements AfterContentChecked {
    private readonly dialogEl;
    private readonly headerEl;
    private previouslyFocused;
    protected readonly i18n: EagamiI18nService;
    private readonly isBrowser;
    private readonly press;
    private readonly scrollLock;
    private holdsScroll;
    readonly width: _angular_core.InputSignal<EaWidth>;
    /**
     * Modal by default: shown via `showModal()`, with the backdrop overlay and
     * the page behind made inert and held from scrolling. When false the dialog
     * floats via `show()` instead, with no backdrop, leaving the page behind
     * scrollable and interactive; Escape still closes (or reports) from inside
     * the dialog, and `closeOnBackdrop` dismisses on a click landing outside
     * the panel. Read when the dialog opens; flipping it while open has no
     * effect.
     */
    readonly modal: _angular_core.InputSignal<boolean>;
    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
    readonly showClose: _angular_core.InputSignal<boolean>;
    /**
     * Disables the built-in close button while a task is in flight (a save, an
     * upload). It governs that button alone; pair it with `closeOnEscape` /
     * `closeOnBackdrop` or `manualClose` to hold the other routes shut too.
     */
    readonly closeDisabled: _angular_core.InputSignal<boolean>;
    /**
     * Hands every close route to the consumer: the dialog reports
     * `closeRequested` and stays open until `open` is set false, so an unsaved
     * edit can be confirmed first. Escape and the backdrop still report, which is
     * what `closeOnEscape` / `closeOnBackdrop` remove entirely.
     */
    readonly manualClose: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly open: _angular_core.ModelSignal<boolean>;
    /** Fires once the dialog has been shown via `showModal()`. */
    readonly opened: _angular_core.OutputEmitterRef<void>;
    /** Fires when the dialog closes (via close button, backdrop, or Escape). */
    readonly closed: _angular_core.OutputEmitterRef<void>;
    /** Fires under `manualClose` for every close the user asks for, leaving the dialog open. */
    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
    readonly panelClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    /** Whether the header slot received content, so labelledby never points at an empty node. */
    protected readonly hasHeader: _angular_core.WritableSignal<boolean>;
    ngAfterContentChecked(): void;
    constructor();
    private holdScroll;
    private dropScroll;
    handleClose(): void;
    /** Every close route the user can take, routed through `manualClose`. */
    protected requestClose(): void;
    handleBackdropClick(event: MouseEvent): void;
    onDocumentClick(event: MouseEvent): void;
    handleCancel(event: Event): void;
    protected handleEscape(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DialogComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DialogComponent, "ea-dialog", never, { "width": { "alias": "width"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "closeDisabled": { "alias": "closeDisabled"; "required": false; "isSignal": true; }; "manualClose": { "alias": "manualClose"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "opened": "opened"; "closed": "closed"; "closeRequested": "closeRequested"; }, never, ["[slot=header]", "*", "[slot=status]", "[slot=footer]"], true, never>;
}

/** Orientation of the divider rule. */
type DividerOrientation = 'horizontal' | 'vertical';
/**
 * Thin separator used to visually divide content. Renders horizontally by
 * default and may include an optional centred label (e.g. "or").
 */
declare class DividerComponent {
    readonly orientation: _angular_core.InputSignal<DividerOrientation>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Renders a heavier rule. */
    readonly thick: _angular_core.InputSignal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-divider--with-label': boolean;
        'ea-divider--thick': boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DividerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DividerComponent, "ea-divider", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "thick": { "alias": "thick"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Edge of the viewport from which the drawer slides in. `start`/`end` are
 * direction-aware (start = left in LTR, right in RTL); `left`/`right` are fixed.
 */
type DrawerPosition = 'left' | 'right' | 'top' | 'bottom' | 'start' | 'end';
/**
 * Extent of the drawer panel along its main axis: width for side drawers,
 * height for top/bottom drawers.
 */
type DrawerSize = EaWidth;
/**
 * How the drawer relates to the page. `overlay` floats over a dimmed,
 * focus-trapped page (modal); `push` opens non-modally with no backdrop and
 * reflows the page content aside so it stays visible and interactive.
 */
type DrawerMode = 'overlay' | 'push';
/**
 * Slide animation used when the drawer opens and closes. `none` shows and hides
 * it instantly; `linear` slides at a constant speed; `eased` slides on an
 * ease-out curve. All durations still collapse to 0ms under reduced motion.
 */
type DrawerAnimation = 'none' | 'linear' | 'eased';
/**
 * Side panel backed by the native `<dialog>` element for browser-managed
 * focus trapping. Slides in from a configurable edge, supports backdrop and
 * Escape dismissal, and exposes `header`, default, and `footer` content
 * slots. The `open` state is a two-way `model()` binding. In `push` mode it
 * opens non-modally and reflows the page content aside instead of overlaying it.
 *
 * Specs running under jsdom need `installNativeDialogShim()` from
 * `@eagami/ui/testing` before opening one.
 */
declare class DrawerComponent implements AfterContentChecked {
    private readonly drawerEl;
    private readonly panelEl;
    private readonly headerEl;
    private previouslyFocused;
    private pushedTarget;
    private pushCleanupTimer;
    private shownAsModal;
    private reopening;
    private isLeaving;
    private pushRaf;
    private leaveTimer;
    private leaveOnEnd;
    private documentClickListener;
    protected readonly i18n: EagamiI18nService;
    private readonly isBrowser;
    private readonly press;
    readonly position: _angular_core.InputSignal<DrawerPosition>;
    /**
     * Extent of the panel along its main axis (width for side drawers, height for
     * top/bottom drawers).
     */
    readonly size: _angular_core.InputSignal<EaWidth>;
    /**
     * `overlay` (default) opens the drawer as a modal over a dimmed page; `push`
     * opens it non-modally and reflows the page content aside.
     */
    readonly mode: _angular_core.InputSignal<DrawerMode>;
    /**
     * Element whose content is pushed aside in `push` mode, as a CSS selector or
     * element reference. Defaults to `document.body`.
     */
    readonly pushTarget: _angular_core.InputSignal<string | HTMLElement | null>;
    readonly closeOnBackdrop: _angular_core.InputSignal<boolean>;
    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
    /** Slide animation used as the panel opens and closes. */
    readonly animation: _angular_core.InputSignal<DrawerAnimation>;
    readonly showClose: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly open: _angular_core.ModelSignal<boolean>;
    /** Fires once the drawer has been shown. */
    readonly opened: _angular_core.OutputEmitterRef<void>;
    /** Fires when the drawer closes (via close button, backdrop, or Escape). */
    readonly closed: _angular_core.OutputEmitterRef<void>;
    readonly panelClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    /** Whether the header slot received content, so labelledby never points at an empty node. */
    protected readonly hasHeader: _angular_core.WritableSignal<boolean>;
    ngAfterContentChecked(): void;
    constructor();
    private showDialog;
    private enter;
    private leave;
    private cancelLeave;
    private finishClose;
    private transitionMs;
    handleClose(): void;
    handleKeydown(event: KeyboardEvent): void;
    private resolvePushTarget;
    private applyPush;
    private clearPush;
    private clearPushProperties;
    private addPushDismiss;
    private removePushDismiss;
    private teardownPush;
    handleBackdropClick(event: MouseEvent): void;
    handleCancel(event: Event): void;
    onDialogClose(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DrawerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DrawerComponent, "ea-drawer", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "mode": { "alias": "mode"; "required": false; "isSignal": true; }; "pushTarget": { "alias": "pushTarget"; "required": false; "isSignal": true; }; "closeOnBackdrop": { "alias": "closeOnBackdrop"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "animation": { "alias": "animation"; "required": false; "isSignal": true; }; "showClose": { "alias": "showClose"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "opened": "opened"; "closed": "closed"; }, never, ["[slot=header]", "*", "[slot=footer]"], true, never>;
}

/** Visual size of the dropdown trigger. */
type DropdownSize = EaSize;
/**
 * Single-select dropdown with a custom popup list. Supports keyboard
 * navigation (arrow keys, Enter/Space to select, Escape to close), closes
 * on outside click or viewport scroll/resize, and integrates with Angular
 * forms via `ControlValueAccessor`. Positioning, dismissal, and SSR-safe
 * scroll handling are provided by `<ea-popover>`.
 */
declare class DropdownComponent implements ControlValueAccessor {
    private readonly elRef;
    private readonly i18n;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    /** Selectable options, either flat or split into groups. */
    readonly options: _angular_core.InputSignal<SelectOptions>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<string>;
    /** Fires with the new value when the user selects an option. */
    readonly changed: _angular_core.OutputEmitterRef<string>;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    readonly focusedIndex: _angular_core.WritableSignal<number>;
    private readonly _formDisabled;
    private typeaheadQuery;
    private typeaheadTimer;
    private onChange;
    private onTouched;
    constructor();
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    private readonly optionGroups;
    /** Whether the consumer supplied groups, which the list exposes as ARIA groups. */
    protected readonly grouped: _angular_core.Signal<boolean>;
    /** Every option in the order given, flattened across groups; drives all index maths. */
    private readonly flatOptions;
    /** Groups to render, each option carrying its index into the flattened list. */
    protected readonly renderedGroups: _angular_core.Signal<RenderedGroup[]>;
    protected readonly selectedIndex: _angular_core.Signal<number>;
    readonly selectedLabel: _angular_core.Signal<string>;
    /** Placeholder text, falling back to the active locale's translation. */
    readonly resolvedPlaceholder: _angular_core.Signal<string>;
    readonly triggerLabelledBy: _angular_core.Signal<string | null>;
    readonly triggerClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-dropdown__trigger--error': boolean;
        'ea-dropdown__trigger--open': boolean;
        'ea-dropdown__trigger--disabled': boolean;
        'ea-dropdown__trigger--readonly': boolean;
    }>;
    readonly menuClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    /** Toggles the dropdown list between open and closed. */
    toggle(): void;
    /** Programmatically selects the given option, closing the list. */
    select(option: SelectOption): void;
    /** Closes the dropdown list without changing the current value. */
    close(): void;
    /** Moves keyboard focus to the dropdown trigger. */
    focus(): void;
    /** Called by `<ea-popover>` when the user clicks outside the dropdown. */
    onPopoverCloseRequested(): void;
    handleKeydown(event: KeyboardEvent): void;
    private selectFocusedOrOpen;
    private focusEdge;
    /** Keeps the keyboard-focused option visible inside the scrolling listbox. */
    private setFocusedIndex;
    private handleTypeahead;
    private moveFocus;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropdownComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropdownComponent, "ea-dropdown", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Content variant: `default` is the bare wordmark, `byline` adds the handcrafted-by line, `tagline` adds the tagline. */
type EagamiWordmarkVariant = 'default' | 'byline' | 'tagline';
/** Layout of the wordmark: `stacked` for multi-line, `inline` for a single line with em-dash separators. */
type EagamiWordmarkLayout = 'stacked' | 'inline';
/**
 * Branded eagami wordmark logo. `size` is the brand text's font-size in px
 * and the rest of the lockup scales proportionally from it; supports three
 * content variants paired with stacked or inline layouts.
 */
declare class EagamiWordmarkComponent {
    protected readonly i18n: EagamiI18nService;
    /** Content variant. */
    readonly variant: _angular_core.InputSignal<EagamiWordmarkVariant>;
    readonly layout: _angular_core.InputSignal<EagamiWordmarkLayout>;
    readonly size: _angular_core.InputSignal<number>;
    /** Renders the wordmark as a link to eagami.com; disable to embed it inside a custom link or static context. */
    readonly linked: _angular_core.InputSignal<boolean>;
    /** Clamps size to a 10px floor and falls back to the default when cleared. */
    protected readonly resolvedSize: _angular_core.Signal<number>;
    protected readonly showOverline: _angular_core.Signal<boolean>;
    protected readonly showTagline: _angular_core.Signal<boolean>;
    protected readonly brandText: _angular_core.Signal<string>;
    protected readonly ariaLabel: _angular_core.Signal<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EagamiWordmarkComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EagamiWordmarkComponent, "ea-eagami-wordmark", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "linked": { "alias": "linked"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Visual size of the empty-state block. */
type EmptyStateSize = EaSize;
/** Heading level used for the title so it fits the surrounding document outline. */
type EmptyStateHeadingLevel = 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
/**
 * Pattern for "no results" or "nothing here yet" screens. Combines an
 * optional icon, title, and description with `[slot=media]` (custom
 * illustration) and `[slot=actions]` (follow-up buttons) content slots.
 */
declare class EmptyStateComponent {
    readonly title: _angular_core.InputSignal<string | undefined>;
    readonly description: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly headingLevel: _angular_core.InputSignal<EmptyStateHeadingLevel>;
    /** Optional icon component rendered in the media area above the title. */
    readonly icon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Renders a dashed frame around the block. */
    readonly bordered: _angular_core.InputSignal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-empty-state--bordered': boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EmptyStateComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EmptyStateComponent, "ea-empty-state", never, { "title": { "alias": "title"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "headingLevel": { "alias": "headingLevel"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; }, {}, never, ["[slot=media]", "[slot=actions]"], true, never>;
}

declare class FieldLabelComponent {
    readonly text: _angular_core.InputSignal<string>;
    /** Optional icon component rendered before the label text. */
    readonly icon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly forId: _angular_core.InputSignal<string | undefined>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly labelId: _angular_core.InputSignal<string | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldLabelComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldLabelComponent, "ea-field-label", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "forId": { "alias": "forId"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "labelId": { "alias": "labelId"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FieldMessagesComponent {
    readonly id: _angular_core.InputSignal<string>;
    readonly error: _angular_core.InputSignal<string | null | undefined>;
    readonly hint: _angular_core.InputSignal<string | null | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FieldMessagesComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FieldMessagesComponent, "ea-field-messages", never, { "id": { "alias": "id"; "required": true; "isSignal": true; }; "error": { "alias": "error"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Visual size of the field (label, control text, spacing, and messages). */
type FormFieldSize = EaSize;
/**
 * Wraps a projected native control (`input`, `select`, or `textarea`) in the
 * library's standard field chrome: a label with required marker, a hint, and
 * error messages, including localized validation errors auto-derived from a
 * bound reactive or template-driven control. The label's `for` and the
 * control's `aria-describedby`, `aria-invalid`, and `aria-required` are wired
 * automatically. The eagami form components render this chrome themselves; use
 * this wrapper so native or custom controls read as part of the same form.
 *
 * The label and aria wiring attach in the browser after render, since the
 * projected control can't be reached before it exists; the server ships the
 * plain markup and the associations complete on hydration.
 */
declare class FormFieldComponent {
    private readonly host;
    /** Text label rendered above the control. */
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Helper text shown below the control; hidden while an error is showing. */
    readonly hint: _angular_core.InputSignal<string | undefined>;
    /** Error message shown below the control; replaces the hint and flags the field invalid. */
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for the projected form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Marks the field as required. */
    readonly required: _angular_core.InputSignal<boolean>;
    /** Visual size of the field; the label, control text, spacing, and messages scale with it. */
    readonly size: _angular_core.InputSignal<EaSize>;
    /** id seed for the label and message wiring; auto-generated when omitted. */
    readonly id: _angular_core.InputSignal<string>;
    private readonly ngControl;
    private readonly rendered;
    private readonly controlEl;
    private baseDescribedBy;
    protected readonly controlId: _angular_core.Signal<string | undefined>;
    private readonly boundControl;
    private readonly errorState;
    protected readonly errorText: _angular_core.Signal<string | null>;
    protected readonly hasError: _angular_core.Signal<boolean>;
    protected readonly showHint: _angular_core.Signal<boolean>;
    constructor();
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FormFieldComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FormFieldComponent, "ea-form-field", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, ["ngControl"], ["*"], true, never>;
}

/** Validator error keys the library ships built-in localized messages for. */
type EaValidationErrorKey = 'required' | 'email' | 'min' | 'max' | 'minlength' | 'maxlength' | 'pattern';
/**
 * Per-error-key message overrides for a form control. Keys are validator error
 * names (`required`, `email`, or any custom validator key); values are the text
 * shown when that error is the active one. Keys left unset fall back to the
 * library's localized default message.
 */
type EaErrorMessages = Partial<Record<string, string>>;

/** Visual size of the file uploader. */
type FileUploaderSize = EaSize;
/** Reason a file was rejected during selection. */
type FileUploaderRejectionReason = 'type' | 'size' | 'count';
/** Detail object emitted on the `rejected` output when one or more files fail validation. */
interface FileUploaderRejection {
    readonly file: File;
    readonly reason: FileUploaderRejectionReason;
}
/**
 * Multi-file uploader with a drag-and-drop zone and a per-file list. Pure UI:
 * the component manages selection, validation, and removal but does not perform
 * any network I/O; consumers are responsible for uploading the resulting
 * `File[]` and (optionally) feeding progress back via the `progress` map.
 *
 * The dropzone icon (default `<ea-icon-upload-cloud>`) is exposed as a content
 * slot via the `icon` attribute: project any element to override it, and the
 * dropzone's size-aware wrapper handles sizing automatically.
 *
 * @example
 * ```html
 * <ea-file-uploader label="Attach files">
 *   <ea-icon-paperclip icon />
 * </ea-file-uploader>
 * ```
 */
declare class FileUploaderComponent implements ControlValueAccessor {
    private readonly fileInputEl;
    private readonly dropzoneEl;
    protected readonly i18n: EagamiI18nService;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    /**
     * Whether a selection adds to the current files or replaces them. Defaults
     * to `true`: picking a second file appends it rather than swapping it in, so
     * a single-file field has to set this to `false` explicitly.
     */
    readonly multiple: _angular_core.InputSignal<boolean>;
    /** Comma-separated MIME types and / or file extensions, e.g. `'image/*,.pdf'`. */
    readonly accept: _angular_core.InputSignal<string | undefined>;
    /** Max size per file in bytes. Files larger than this are rejected. */
    readonly maxSize: _angular_core.InputSignal<number | undefined>;
    /** Max total number of files. Extra files are rejected. */
    readonly maxFiles: _angular_core.InputSignal<number | undefined>;
    /** Toggle the file list under the dropzone. */
    readonly showFileList: _angular_core.InputSignal<boolean>;
    /**
     * Optional per-file progress (0-100). Keyed by `File` object identity, so
     * consumers must keep the same `File` references between change-detection
     * runs. When unset, no progress bar is rendered.
     */
    readonly progress: _angular_core.InputSignal<ReadonlyMap<File, number> | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    /** Two-way binding to the current `File[]`. Also written by Angular forms. */
    readonly value: _angular_core.ModelSignal<readonly File[]>;
    /** Fires when one or more selected files fail validation. */
    readonly rejected: _angular_core.OutputEmitterRef<readonly FileUploaderRejection[]>;
    /** Fires whenever a file is removed via its row's X button. */
    readonly fileRemoved: _angular_core.OutputEmitterRef<File>;
    /**
     * Fires when a drag enters or leaves the dropzone. The component consumes
     * the drag events it handles, so a wrapper tracking its own drag styling
     * reads the state from here rather than from the DOM.
     */
    readonly dragOverChanged: _angular_core.OutputEmitterRef<boolean>;
    protected readonly isDragOver: _angular_core.WritableSignal<boolean>;
    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    protected readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    protected readonly errorText: _angular_core.Signal<string | null>;
    protected readonly hasError: _angular_core.Signal<boolean>;
    protected readonly showError: _angular_core.Signal<boolean>;
    protected readonly showHint: _angular_core.Signal<boolean>;
    protected readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-file-uploader-field--error': boolean;
        'ea-file-uploader-field--disabled': boolean;
        'ea-file-uploader-field--drag-over': boolean;
        'ea-file-uploader-field--focused': boolean;
    }>;
    protected readonly errorId: _angular_core.Signal<string>;
    protected readonly hintId: _angular_core.Signal<string>;
    protected readonly constraintsId: _angular_core.Signal<string>;
    protected readonly describedBy: _angular_core.Signal<string | null>;
    /** Joined human-readable description of accept / maxSize / maxFiles limits. */
    protected readonly constraintsText: _angular_core.Signal<string>;
    protected readonly promptText: _angular_core.Signal<string>;
    writeValue(value: readonly File[] | null | undefined): void;
    registerOnChange(fn: (value: readonly File[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    protected openFilePicker(): void;
    protected onDropzoneKeydown(event: KeyboardEvent): void;
    protected onDropzoneFocus(): void;
    protected onDropzoneBlur(): void;
    protected onFileSelected(event: Event): void;
    protected onDragEnter(event: DragEvent): void;
    protected onDragOver(event: DragEvent): void;
    protected onDragLeave(event: DragEvent): void;
    protected onDrop(event: DragEvent): void;
    private setDragOver;
    protected removeFile(file: File): void;
    private acceptFiles;
    protected formatBytes(bytes: number): string;
    protected iconKey(file: File): 'image' | 'film' | 'music' | 'archive' | 'text' | 'file';
    protected progressFor(file: File): number | undefined;
    /** Stable track key for the `@for` over `value()`. */
    protected trackFile(_index: number, file: File): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileUploaderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileUploaderComponent, "ea-file-uploader", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "accept": { "alias": "accept"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "maxFiles": { "alias": "maxFiles"; "required": false; "isSignal": true; }; "showFileList": { "alias": "showFileList"; "required": false; "isSignal": true; }; "progress": { "alias": "progress"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "rejected": "rejected"; "fileRemoved": "fileRemoved"; "dragOverChanged": "dragOverChanged"; }, never, ["[icon]"], true, never>;
}

/** Visual size of the input. */
type InputSize = EaSize;
/** HTML `type` attribute applied to the underlying `<input>`. */
type InputType = 'text' | 'email' | 'password' | 'number' | 'search' | 'tel' | 'url';
/**
 * Single-line text field with label, hint, and error message support.
 * Includes a built-in show/hide toggle for `password` inputs and integrates
 * with Angular forms via `ControlValueAccessor`. Prefix and suffix content
 * can be projected via the `prefix` and `suffix` slots.
 */
declare class InputComponent implements ControlValueAccessor {
    readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    private readonly injector;
    protected readonly i18n: EagamiI18nService;
    /** Text label rendered above the field. */
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Accessible name for the control when no visible `label` is set. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    /** ARIA role applied to the native input, e.g. `combobox` for a typeahead host. */
    readonly role: _angular_core.InputSignal<string | undefined>;
    /** Expanded state of a controlled popup, forwarded as `aria-expanded`. */
    readonly ariaExpanded: _angular_core.InputSignal<boolean | undefined>;
    /** `id` of the popup element the input controls, forwarded as `aria-controls`. */
    readonly ariaControls: _angular_core.InputSignal<string | undefined>;
    /** `id` of the active option in a controlled popup, forwarded as `aria-activedescendant`. */
    readonly ariaActivedescendant: _angular_core.InputSignal<string | undefined>;
    /** Autocomplete behavior hint, forwarded as `aria-autocomplete`. */
    readonly ariaAutocomplete: _angular_core.InputSignal<"none" | "inline" | "list" | "both" | undefined>;
    /** Native input type; `password` adds a built-in show/hide toggle. */
    readonly type: _angular_core.InputSignal<InputType>;
    /** Placeholder shown while the field is empty. */
    readonly placeholder: _angular_core.InputSignal<string>;
    /** Leading icon component rendered before the text, e.g. a search or filter glyph. */
    readonly icon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Keeps the leading icon while the field has a value; when false it shows only alongside the placeholder. */
    readonly keepIcon: _angular_core.InputSignal<boolean>;
    /** Visual size of the field. */
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Helper text shown below the field; hidden while an error is showing. */
    readonly hint: _angular_core.InputSignal<string | undefined>;
    /** Error message shown below the field; replaces the hint and flags the field invalid. */
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Disables the field. */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /** Renders the field read-only. */
    readonly readonly: _angular_core.InputSignal<boolean>;
    /** Marks the field as required. */
    readonly required: _angular_core.InputSignal<boolean>;
    /** Value for the native `autocomplete` attribute. */
    readonly autocomplete: _angular_core.InputSignal<string | undefined>;
    /** Value for the native `spellcheck` attribute; left to the browser default when unset. */
    readonly spellcheck: _angular_core.InputSignal<boolean | undefined>;
    /** `id` of a `<datalist>` to associate for native suggestions. */
    readonly list: _angular_core.InputSignal<string | undefined>;
    /** Minimum value for `type="number"`; the value is clamped to it on blur. */
    readonly min: _angular_core.InputSignal<number | undefined>;
    /** Maximum value for `type="number"`; the value is clamped to it on blur. */
    readonly max: _angular_core.InputSignal<number | undefined>;
    /** Step increment for `type="number"`. */
    readonly step: _angular_core.InputSignal<number | undefined>;
    /** Maximum number of characters; enforced for `type="number"`, where native `maxlength` is ignored. */
    readonly maxLength: _angular_core.InputSignal<number | undefined>;
    /** Minimum number of characters (native `minlength`). */
    readonly minLength: _angular_core.InputSignal<number | undefined>;
    /** Focuses the field once, after it first renders. */
    readonly autofocus: _angular_core.InputSignal<boolean>;
    /** Shows the reveal toggle for `password` inputs. */
    readonly showPasswordToggle: _angular_core.InputSignal<boolean>;
    /** Shows a clear button while the field has a value. */
    readonly clearable: _angular_core.InputSignal<boolean>;
    /** `id` applied to the native input and label `for`; auto-generated when omitted. */
    readonly id: _angular_core.InputSignal<string>;
    /** Current field value; two-way bindable via `[(value)]`. */
    readonly value: _angular_core.ModelSignal<string>;
    readonly isFocused: _angular_core.WritableSignal<boolean>;
    readonly passwordVisible: _angular_core.WritableSignal<boolean>;
    private readonly _formDisabled;
    /** Fires when the input receives focus. */
    readonly focused: _angular_core.OutputEmitterRef<FocusEvent>;
    /** Fires when the input loses focus. */
    readonly blurred: _angular_core.OutputEmitterRef<FocusEvent>;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly effectiveType: _angular_core.Signal<InputType>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly showClear: _angular_core.Signal<boolean>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-input-wrapper--error': boolean;
        'ea-input-wrapper--focused': boolean;
        'ea-input-wrapper--disabled': boolean;
        'ea-input-wrapper--readonly': boolean;
    }>;
    /** Characters a bounded number field can hold, from `maxLength` or its bounds' digits. */
    private readonly numberCharCapacity;
    /** Caps a bounded number field to the widest value it can hold. */
    readonly numberWidth: _angular_core.Signal<string | null>;
    constructor();
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleInput(event: Event): void;
    handleKeydown(event: KeyboardEvent): void;
    handleWheel(event: WheelEvent): void;
    handleFocus(event: FocusEvent): void;
    handleBlur(event: FocusEvent): void;
    /** Clamps a number value into `[min, max]` once editing finishes. */
    private clampToBounds;
    /** Toggles the password reveal state for `type="password"` inputs. */
    togglePasswordVisibility(): void;
    protected onClearMousedown(event: MouseEvent): void;
    /** Clear the current value and restore focus to the input. */
    clear(): void;
    /** Moves keyboard focus to the underlying native input element. */
    focus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InputComponent, "ea-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "ariaExpanded": { "alias": "aria-expanded"; "required": false; "isSignal": true; }; "ariaControls": { "alias": "aria-controls"; "required": false; "isSignal": true; }; "ariaActivedescendant": { "alias": "aria-activedescendant"; "required": false; "isSignal": true; }; "ariaAutocomplete": { "alias": "aria-autocomplete"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "keepIcon": { "alias": "keepIcon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "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; }; "autocomplete": { "alias": "autocomplete"; "required": false; "isSignal": true; }; "spellcheck": { "alias": "spellcheck"; "required": false; "isSignal": true; }; "list": { "alias": "list"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "maxLength": { "alias": "maxLength"; "required": false; "isSignal": true; }; "minLength": { "alias": "minLength"; "required": false; "isSignal": true; }; "autofocus": { "alias": "autofocus"; "required": false; "isSignal": true; }; "showPasswordToggle": { "alias": "showPasswordToggle"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "focused": "focused"; "blurred": "blurred"; }, never, ["[slot=prefix]", "[slot=suffix]"], true, never>;
}

/** Placement of the menu list relative to its trigger. */
type MenuPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
/** Visual size of the menu, shared by all of its items. */
type MenuSize = EaSize;
/**
 * Popup action menu attached to any focusable element via the
 * `[eaMenuTrigger]` directive. Supports keyboard navigation
 * (arrow keys, Home/End), closes on outside click or Escape, and restores
 * focus to the trigger on close. Positioning, dismissal, and SSR-safe scroll
 * handling are provided by `<ea-popover>`.
 */
declare class MenuComponent {
    private readonly injector;
    private readonly i18n;
    private readonly listEl;
    readonly placement: _angular_core.InputSignal<MenuPlacement>;
    /** Visual size of the menu; every item inherits it. */
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Max height of the scrollable list as a CSS length; tall menus scroll past it. */
    readonly maxHeight: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    /** Accessible label for the menu, falling back to the active locale. */
    readonly resolvedAriaLabel: _angular_core.Signal<string>;
    readonly open: _angular_core.ModelSignal<boolean>;
    /** Fires when the menu opens. */
    readonly opened: _angular_core.OutputEmitterRef<void>;
    /** Fires when the menu closes. */
    readonly closed: _angular_core.OutputEmitterRef<void>;
    /** Trigger element currently anchoring the menu. Signal-typed so `<ea-popover>` reacts when it changes. */
    protected readonly triggerEl: _angular_core.WritableSignal<HTMLElement | undefined>;
    readonly activeItemId: _angular_core.WritableSignal<string | null>;
    constructor();
    /** Toggles the menu open state, anchoring it to the given trigger element. */
    toggleAt(triggerEl: HTMLElement): void;
    /** Opens the menu anchored to the given trigger element and focuses the first item. */
    openAt(triggerEl: HTMLElement): void;
    /**
     * Closes the menu if it is open. Pass `restoreFocus: true` to return focus
     * to the trigger element (used when closing via Escape or item activation;
     * not used on outside click, where the user has chosen a new focus target).
     */
    close(restoreFocus?: boolean): void;
    /** Called by `<ea-popover>` when the user clicks outside the menu. */
    onPopoverCloseRequested(): void;
    private getEnabledItems;
    /**
     * `preventScroll: true` is critical here. The menu list is `position: fixed`
     * but its DOM ancestor is whatever element hosts the menu (often a sticky
     * header). When `.focus()` is called without `preventScroll`, Chromium uses
     * the focused element's DOM-tree position (inside the sticky ancestor) rather
     * than its rendered fixed position to decide whether to scroll, which on a
     * scrolled page nudges the document up by a few pixels per open, until the
     * trigger reaches the top edge. The same guard applies to keyboard navigation
     * and restoring focus on close.
     */
    private focusFirstItem;
    private focusItem;
    onKeydown(event: KeyboardEvent): void;
    onEscape(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuComponent, "ea-menu", never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "opened": "opened"; "closed": "closed"; }, never, ["*"], true, never>;
}

/** Visual style of a menu item; `danger` for destructive actions. */
type MenuItemVariant = 'default' | 'danger';
/**
 * Selectable row inside an `ea-menu`. Supports leading icons via the `icon`
 * content slot, a disabled state, and a `danger` variant for destructive
 * actions. Inherits its size from the parent menu, and activating an item
 * closes that menu.
 */
declare class MenuItemComponent {
    private readonly menu;
    protected readonly itemId: string;
    protected readonly tabIndex: _angular_core.Signal<0 | -1>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly variant: _angular_core.InputSignal<MenuItemVariant>;
    /** Fires when the item is activated; the parent menu closes immediately afterwards. */
    readonly clicked: _angular_core.OutputEmitterRef<MouseEvent>;
    handleClick(event: MouseEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuItemComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuItemComponent, "ea-menu-item", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; }, { "clicked": "clicked"; }, never, ["[slot=icon]", "*"], true, never>;
}

/**
 * Wires a focusable host element (typically a button) to an `ea-menu`,
 * handling click and keyboard activation (ArrowDown/Enter/Space to open,
 * Escape to close) and applying the appropriate ARIA attributes.
 */
declare class MenuTriggerDirective {
    private readonly el;
    private readonly renderer;
    readonly menu: _angular_core.InputSignal<MenuComponent>;
    constructor();
    handleClick(): void;
    handleKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuTriggerDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<MenuTriggerDirective, "[eaMenuTrigger]", never, { "menu": { "alias": "eaMenuTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Placement of the popover relative to its anchor. Each placement names the
 * side of the anchor the popover attaches to, optionally followed by a corner
 * suffix (`-start` or `-end`) that decides the alignment along the perpendicular
 * axis. The plain side names (`top`, `bottom`, `left`, `right`) centre the
 * popover on that axis.
 */
type PopoverPlacement = 'top' | 'top-start' | 'top-end' | 'bottom' | 'bottom-start' | 'bottom-end' | 'left' | 'right';
interface PopoverPositionResult {
    /** Top coordinate in viewport (px); pairs with `position: fixed`. */
    readonly top: number;
    /** Left coordinate in viewport (px). */
    readonly left: number;
    /** Width hint when the popover should match the anchor's width. */
    readonly width?: number;
    /** The anchor's measured width, for a caller capping the popover against it. */
    readonly anchorWidth: number;
    /** Effective placement after any flip logic ran. */
    readonly placement: PopoverPlacement;
}
interface PopoverPositionOptions {
    readonly placement: PopoverPlacement;
    /** Gap in px between the anchor and the popover. Default 4. */
    readonly offset?: number;
    /** Flip to the opposite side when the requested side overflows the viewport. Default true. */
    readonly flip?: boolean;
    /** Clamp inside the viewport when the popover still overflows after any flip. Default true. */
    readonly clamp?: boolean;
    /** Margin from the viewport edge in px when clamping. Default 8. */
    readonly margin?: number;
    /** Set the popover's width to match the anchor's. Useful for dropdown-style menus. */
    readonly matchAnchorWidth?: boolean;
    /** Right-to-left context. Swaps `-start`/`-end` alignment so they track the reading direction. */
    readonly rtl?: boolean;
}
interface Rect {
    readonly width: number;
    readonly height: number;
}
interface AnchorRect extends Rect {
    readonly top: number;
    readonly bottom: number;
    readonly left: number;
    readonly right: number;
}
interface Viewport {
    readonly width: number;
    readonly height: number;
}
/**
 * Computes the viewport-space top/left for a popover anchored to `anchorRect`,
 * applying optional flip-on-overflow and edge-clamp logic. Pure function, no
 * DOM access. Both `<ea-popover>` and `[eaTooltip]` consume this.
 *
 * @param anchorRect  The anchor element's `getBoundingClientRect()`.
 * @param popoverRect Width and height of the popover (post-render measurement).
 * @param viewport    Viewport dimensions (`window.innerWidth/Height`).
 * @param options     Placement and behavior flags.
 */
declare function computePopoverPosition(anchorRect: AnchorRect, popoverRect: Rect, viewport: Viewport, options: PopoverPositionOptions): PopoverPositionResult;

/** ARIA role to apply to the popover surface. */
type PopoverRole = 'menu' | 'listbox' | 'dialog' | 'tooltip' | 'grid';
/**
 * How the popover should respond to scroll / resize events while open.
 *
 * - `reposition` (default): re-measure the anchor and update the popover's
 *   coordinates so it stays attached. Suitable for menus and tooltips.
 * - `close`: request close. Suitable for dropdown lists and the colour-picker
 *   popover, where re-tracking a tall popover during a scroll feels intrusive.
 * - `ignore`: do nothing. The popover stays at its initial coordinates and
 *   may visually detach from a scrolling anchor; useful when the anchor is
 *   guaranteed not to move (e.g. inside a non-scrolling region).
 */
type PopoverScrollBehavior = 'reposition' | 'close' | 'ignore';
/** Width cap for a popover surface: px, or the anchor's own width. */
type PopoverMaxWidth = number | 'anchor';
/**
 * Floating-element primitive. Renders projected content as `position: fixed`
 * anchored to an external element, with flip-on-overflow, viewport clamping,
 * outside-click and Escape dismissal, and SSR-safe scroll / resize handling.
 *
 * The primitive is intentionally low-level: a parent component drives the
 * `[open]` state and listens for `(closeRequested)` to mirror it back. Internal
 * library components (`<ea-menu>`, `<ea-dropdown>`, `<ea-color-picker>`,
 * `<ea-date-picker>`, `[eaTooltip]`) compose on top of it; downstream apps can
 * use it directly to build their own popover-based UI.
 *
 * @example
 * ```html
 * <button #trigger (click)="open.set(!open())">Open</button>
 * <ea-popover [anchor]="trigger" [open]="open()" (closeRequested)="open.set(false)">
 *   <div>Popover content</div>
 * </ea-popover>
 * ```
 */
declare class PopoverComponent {
    private readonly destroyRef;
    private readonly press;
    private readonly surfaceEl;
    /** Anchor element the popover positions itself against. */
    readonly anchor: _angular_core.InputSignal<HTMLElement | ElementRef<HTMLElement> | undefined>;
    /** Whether the popover is currently open. */
    readonly open: _angular_core.InputSignal<boolean>;
    /** Where the popover attaches relative to the anchor. */
    readonly placement: _angular_core.InputSignal<PopoverPlacement>;
    /** ARIA role applied to the popover surface. */
    readonly role: _angular_core.InputSignal<PopoverRole>;
    /** Accessible label. Falls back to nothing; consumers should provide one when no visible heading is in the popover. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    /** Id of the element that labels the popover surface, forwarded as `aria-labelledby`. */
    readonly ariaLabelledby: _angular_core.InputSignal<string | undefined>;
    /** Keep Tab and Shift+Tab cycling within the surface while open (dialog pattern). */
    readonly trapFocus: _angular_core.InputSignal<boolean>;
    /** DOM id for the surface so trigger elements can reference it via aria-controls. */
    readonly surfaceId: _angular_core.InputSignal<string>;
    /**
     * Gap in px between the anchor and the popover. Defaults to 2 so an open panel
     * clears the anchor's active focus ring instead of sitting flush over it.
     */
    readonly offset: _angular_core.InputSignal<number>;
    /** Flip to the opposite side when the requested side overflows the viewport. */
    readonly flip: _angular_core.InputSignal<boolean>;
    /** Clamp the popover inside the viewport when it would otherwise overflow. */
    readonly clamp: _angular_core.InputSignal<boolean>;
    /** Set the popover's `min-width` to match the anchor's width (dropdown pattern). */
    readonly matchAnchorWidth: _angular_core.InputSignal<boolean>;
    /**
     * Widest the surface may grow: a px value, or `anchor` to cap it at the
     * anchor's own width so long content truncates instead of widening the panel.
     */
    readonly maxWidth: _angular_core.InputSignal<PopoverMaxWidth | undefined>;
    /** Close on click outside the popover and the anchor. */
    readonly closeOnOutsideClick: _angular_core.InputSignal<boolean>;
    /** Close on Escape. */
    readonly closeOnEscape: _angular_core.InputSignal<boolean>;
    /** What to do on scroll / resize while open. */
    readonly scrollBehavior: _angular_core.InputSignal<PopoverScrollBehavior>;
    /** Requested close. The parent should mirror this into `[open]`. */
    readonly closeRequested: _angular_core.OutputEmitterRef<void>;
    private readonly position;
    private latched;
    /** True placement after flip, for class-based styling (e.g. arrow direction). */
    readonly effectivePlacement: _angular_core.Signal<PopoverPlacement>;
    /** Latches true once the post-rAF reposition has run, so the surface is
     * only revealed after its dimensions are guaranteed stable. Reset on close. */
    private readonly stable;
    /** True once the first `reposition()` has resolved a placement on a
     * laid-out surface. Drives the `--positioned` class. */
    readonly isPositioned: _angular_core.Signal<boolean>;
    /** Class list for the surface. Computed in TS so the placement key (with
     * its interpolated suffix) and the positioned modifier compose cleanly. */
    readonly surfaceClass: _angular_core.Signal<string>;
    /** Inline style applied to the surface element. */
    readonly surfaceStyle: _angular_core.Signal<Record<string, string>>;
    constructor();
    private resolveAnchor;
    private reposition;
    onDocumentClick(event: MouseEvent): void;
    onSurfaceKeydown(event: KeyboardEvent): void;
    onEscape(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PopoverComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PopoverComponent, "ea-popover", never, { "anchor": { "alias": "anchor"; "required": true; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "role": { "alias": "role"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "ariaLabelledby": { "alias": "aria-labelledby"; "required": false; "isSignal": true; }; "trapFocus": { "alias": "trapFocus"; "required": false; "isSignal": true; }; "surfaceId": { "alias": "surfaceId"; "required": false; "isSignal": true; }; "offset": { "alias": "offset"; "required": false; "isSignal": true; }; "flip": { "alias": "flip"; "required": false; "isSignal": true; }; "clamp": { "alias": "clamp"; "required": false; "isSignal": true; }; "matchAnchorWidth": { "alias": "matchAnchorWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "scrollBehavior": { "alias": "scrollBehavior"; "required": false; "isSignal": true; }; }, { "closeRequested": "closeRequested"; }, never, ["*"], true, never>;
}

/** Visual size of the multi-select trigger. */
type MultiSelectSize = EaSize;
/**
 * Multi-select dropdown. Renders selections as removable `<ea-tag>` chips
 * inside the trigger, opens a popover containing an optional search input,
 * a tri-state "Select all" toggle, and a list of `<ea-checkbox>` options.
 * The wire value is a `readonly string[]` of selected option values, ordered
 * to match the input `options` array. Closes on outside click / scroll, and
 * integrates with Angular forms via `ControlValueAccessor`.
 */
declare class MultiSelectComponent implements ControlValueAccessor {
    protected readonly wrapperEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    private readonly popover;
    protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    protected readonly searchEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    private readonly listEl;
    private readonly optionLabelEls;
    protected readonly i18n: EagamiI18nService;
    private readonly injector;
    private readonly destroyRef;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Accessible name for the combobox when no visible `label` is set. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly searchPlaceholder: _angular_core.InputSignal<string | undefined>;
    /** Selectable options, either flat or split into groups. */
    readonly options: _angular_core.InputSignal<SelectOptions>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Toggle the search input at the top of the popover. */
    readonly searchable: _angular_core.InputSignal<boolean>;
    /** Toggle the "Select all" row at the top of the option list. */
    readonly selectAll: _angular_core.InputSignal<boolean>;
    /**
     * Offer a "Create" row when the search text matches no option, for a value
     * the list cannot know about yet (a new tag, a new person). The component
     * only reports the text through `created`; the consumer creates the record
     * and pushes its value into `value`.
     */
    readonly allowCreate: _angular_core.InputSignal<boolean>;
    /** Max number of chips shown inside the trigger; the rest collapse into a "+N more" pill. `0` removes the cap so every chip shows and the row scrolls horizontally. */
    readonly maxVisibleChips: _angular_core.InputSignal<number>;
    /**
     * Widest a selected-value chip may grow, in px; a longer label ellipsizes
     * and reveals its full text in a tooltip.
     */
    readonly maxChipWidth: _angular_core.InputSignal<number | undefined>;
    /**
     * Tallest the option popover may grow, in px, before the option list
     * scrolls; left unset, the popover keeps its built-in 20rem cap.
     */
    readonly popoverMaxHeight: _angular_core.InputSignal<number | undefined>;
    /**
     * Widest the option popover may grow: a px value, or `anchor` to hold it to
     * the field's own width so a long option truncates instead of widening it.
     */
    readonly popoverMaxWidth: _angular_core.InputSignal<PopoverMaxWidth>;
    readonly id: _angular_core.InputSignal<string>;
    /** Selected option values, in the original options order. */
    readonly value: _angular_core.ModelSignal<readonly string[]>;
    /** Fires with the new value whenever the selection changes. */
    readonly changed: _angular_core.OutputEmitterRef<readonly string[]>;
    /** Fires with the typed text when the user takes the `allowCreate` row. */
    readonly created: _angular_core.OutputEmitterRef<string>;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    readonly searchTerm: _angular_core.WritableSignal<string>;
    /** Index into `filteredOptions()` for keyboard navigation. `-1` when none focused. */
    readonly focusedIndex: _angular_core.WritableSignal<number>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    /** Set-backed lookup for `selectedSet().has(value)`. */
    readonly selectedSet: _angular_core.Signal<Set<string>>;
    private readonly optionGroups;
    /** Whether the consumer supplied groups, which the list exposes as ARIA groups. */
    protected readonly grouped: _angular_core.Signal<boolean>;
    /** Every option in the order given, flattened across groups. */
    private readonly flatOptions;
    private readonly filteredGroups;
    /** Options matching the current search term (case- and accent-insensitive substring on label). */
    readonly filteredOptions: _angular_core.Signal<readonly SelectOption[]>;
    /** Groups to render, each option carrying its index into `filteredOptions`. */
    protected readonly renderedGroups: _angular_core.Signal<RenderedGroup[]>;
    /** Currently selected options, ordered to match the input `options`. */
    readonly selectedOptions: _angular_core.Signal<readonly SelectOption[]>;
    readonly hasValue: _angular_core.Signal<boolean>;
    readonly listboxId: _angular_core.Signal<string>;
    /** Whether the Select-all row renders as the first option in the listbox. */
    protected readonly selectAllVisible: _angular_core.Signal<boolean>;
    /** Row-index offset the Select-all row adds ahead of the filtered options. */
    protected readonly selectAllOffset: _angular_core.Signal<1 | 0>;
    /** The text a Create row would carry, or `''` when no such row is offered. */
    protected readonly creatableText: _angular_core.Signal<string>;
    /** Row index of the Create row, which sits after the options, or `-1`. */
    protected readonly createRow: _angular_core.Signal<number>;
    private readonly rowCount;
    protected readonly selectAllAriaChecked: _angular_core.Signal<"true" | "mixed" | "false">;
    /** Id of the keyboard-focused option, for `aria-activedescendant`. */
    readonly activeOptionId: _angular_core.Signal<string | null>;
    /** Chips visible inside the trigger, capped by `maxVisibleChips`. */
    readonly visibleChips: _angular_core.Signal<readonly SelectOption[]>;
    /** Count behind the "+N more" pill, or `0` when all chips fit. */
    readonly hiddenChipCount: _angular_core.Signal<number>;
    /** Tri-state of the Select-all checkbox over the **currently filtered** list. */
    readonly selectAllState: _angular_core.Signal<"some" | "none" | "all">;
    readonly resolvedPlaceholder: _angular_core.Signal<string>;
    readonly resolvedSearchPlaceholder: _angular_core.Signal<string>;
    readonly triggerClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-multi-select__trigger--error': boolean;
        'ea-multi-select__trigger--open': boolean;
        'ea-multi-select__trigger--disabled': boolean;
        'ea-multi-select__trigger--readonly': boolean;
        'ea-multi-select__trigger--placeholder': boolean;
    }>;
    readonly menuClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    /** Values whose rendered option label is currently clipped by the panel. */
    protected readonly clippedOptions: _angular_core.WritableSignal<ReadonlySet<string>>;
    constructor();
    writeValue(val: readonly string[] | null | undefined): void;
    registerOnChange(fn: (value: readonly string[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    toggle(): void;
    close(): void;
    /** Called by `<ea-popover>` when the user clicks outside or scrolls. */
    onPopoverCloseRequested(): void;
    /** Toggle one option's membership in the selection. */
    toggleOption(opt: SelectOption): void;
    /**
     * Clicks on the bordered box (trigger, padding, chevron) all toggle; the
     * clear button and chip remove buttons stop propagation before reaching
     * here. The combobox element only takes focus natively when clicked
     * directly, so focus is restored explicitly for the activedescendant model.
     */
    protected onTriggerAreaClick(): void;
    protected onOptionClick(opt: SelectOption, index: number): void;
    protected onSelectAllClick(): void;
    private restoreTypingFocus;
    /**
     * Remove a single chip from the trigger. `<ea-tag>` already stops the
     * click from bubbling to the trigger's `(click)`, so no event handling
     * is needed here.
     */
    removeChip(opt: SelectOption): void;
    /** Clear every selection via the trigger × button. */
    clear(event: Event): void;
    /**
     * Toggle the Select-all checkbox. If any filtered option is unselected, the
     * action selects all filtered. Otherwise, the action removes every filtered
     * value from the selection. Disabled options are skipped either way.
     */
    toggleSelectAll(): void;
    onSearchInput(event: Event): void;
    private soleOptionRow;
    private clearSearchForNextValue;
    handleTriggerKeydown(event: KeyboardEvent): void;
    /**
     * Keyboard navigation inside the popover. Bound to both the search input
     * and each option row; Space passes through to the search input naturally
     * so users can type spaces in their query.
     */
    handlePopoverKeydown(event: KeyboardEvent): void;
    private moveFocusedRow;
    /** Enter/Space on the focused row: row 0 is Select-all when visible. */
    private activateRow;
    /** Report the typed text, then clear it so the new value can be followed by another. */
    protected createOption(): void;
    /** Reorder a value-set against the input `options` array. */
    private orderedValues;
    private optionsFor;
    private resetEditState;
    private commit;
    /**
     * Re-reads which option labels are clipped. The result is written back only
     * when the set actually differs, since an unconditional write would render,
     * re-measure, and write again forever.
     */
    private measureClippedOptions;
    private watchListWidth;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MultiSelectComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MultiSelectComponent, "ea-multi-select", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "searchable": { "alias": "searchable"; "required": false; "isSignal": true; }; "selectAll": { "alias": "selectAll"; "required": false; "isSignal": true; }; "allowCreate": { "alias": "allowCreate"; "required": false; "isSignal": true; }; "maxVisibleChips": { "alias": "maxVisibleChips"; "required": false; "isSignal": true; }; "maxChipWidth": { "alias": "maxChipWidth"; "required": false; "isSignal": true; }; "popoverMaxHeight": { "alias": "popoverMaxHeight"; "required": false; "isSignal": true; }; "popoverMaxWidth": { "alias": "popoverMaxWidth"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "created": "created"; }, never, never, true, never>;
}

/** Visual size of the number input. */
type NumberInputSize = EaSize;
/**
 * Numeric field with min/max/step bounds, native arrow-key stepping, and
 * the standard label, hint, and error chrome. The native input carries the
 * `spinbutton` role, so arrow keys step it; the steppers are pointer
 * affordances. Integrates with Angular forms via `ControlValueAccessor`.
 */
declare class NumberInputComponent implements ControlValueAccessor {
    readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    protected readonly i18n: EagamiI18nService;
    /** Text label rendered above the field. */
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Placeholder shown while the field is empty. */
    readonly placeholder: _angular_core.InputSignal<string>;
    /** Visual size of the field. */
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Helper text shown below the field; hidden while an error is showing. */
    readonly hint: _angular_core.InputSignal<string | undefined>;
    /** Error message shown below the field; replaces the hint and flags the field invalid. */
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Disables the field. */
    readonly disabled: _angular_core.InputSignal<boolean>;
    /** Renders the field read-only. */
    readonly readonly: _angular_core.InputSignal<boolean>;
    /** Marks the field as required. */
    readonly required: _angular_core.InputSignal<boolean>;
    /** Minimum value; typed values are clamped to it on blur and the steppers respect it. */
    readonly min: _angular_core.InputSignal<number | undefined>;
    /** Maximum value; typed values are clamped to it on blur. */
    readonly max: _angular_core.InputSignal<number | undefined>;
    /** Amount each arrow-key step adds or subtracts. */
    readonly step: _angular_core.InputSignal<number>;
    /**
     * Caps how many characters the field accepts, counting the digits, the minus
     * sign, and the decimal point. Also sets how wide the field renders; without
     * it the field is six characters wide.
     */
    readonly maxDigits: _angular_core.InputSignal<number | undefined>;
    /** Whether negative values are allowed; when `false` the value floors at 0. */
    readonly allowNegative: _angular_core.InputSignal<boolean>;
    /** Accessible name for the field when no visible `label` is set. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    /** `id` applied to the native input and label `for`; auto-generated when omitted. */
    readonly id: _angular_core.InputSignal<string>;
    /** Current field value; `null` when empty. Two-way bindable via `[(value)]`. */
    readonly value: _angular_core.ModelSignal<number | null>;
    /** Fires with the new value whenever it changes. */
    readonly changed: _angular_core.OutputEmitterRef<number | null>;
    /** Fires when the input receives focus. */
    readonly focused: _angular_core.OutputEmitterRef<FocusEvent>;
    /** Fires when the input loses focus. */
    readonly blurred: _angular_core.OutputEmitterRef<FocusEvent>;
    readonly isFocused: _angular_core.WritableSignal<boolean>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly isInteractive: _angular_core.Signal<boolean>;
    readonly effectiveMin: _angular_core.Signal<number | undefined>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-number-input-wrapper--error': boolean;
        'ea-number-input-wrapper--focused': boolean;
        'ea-number-input-wrapper--disabled': boolean;
        'ea-number-input-wrapper--readonly': boolean;
    }>;
    constructor();
    writeValue(val: number | null): void;
    registerOnChange(fn: (value: number | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    protected handleInput(): void;
    private enforceMaxDigits;
    protected handleFocus(event: FocusEvent): void;
    protected handleBlur(event: FocusEvent): void;
    protected handleWheel(event: WheelEvent): void;
    protected handleKeydown(event: KeyboardEvent): void;
    /** Moves keyboard focus to the underlying native input element. */
    focus(): void;
    private commitFromElement;
    private clampToBounds;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NumberInputComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NumberInputComponent, "ea-number-input", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "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; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "maxDigits": { "alias": "maxDigits"; "required": false; "isSignal": true; }; "allowNegative": { "alias": "allowNegative"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; "focused": "focused"; "blurred": "blurred"; }, never, never, true, never>;
}

/** Horizontal alignment of paginator controls within their container. */
type PaginatorAlign = 'left' | 'center' | 'right';
/** Visual size of the paginator. */
type PaginatorSize = EaSize;
/** Snapshot of the paginator's page and page size. */
interface PaginatorState {
    page: number;
    pageSize: number;
}
/**
 * Page navigation control with previous/next buttons, numbered page jumps,
 * an optional page-size selector, and a range label. Exposes `page` and
 * `pageSize` as two-way `model()` bindings and emits a single `changed`
 * event whenever either changes.
 */
declare class PaginatorComponent {
    protected readonly i18n: EagamiI18nService;
    protected readonly sizeSelectId: string;
    readonly totalItems: _angular_core.InputSignal<number>;
    readonly pageSizeOptions: _angular_core.InputSignal<number[]>;
    readonly showPageSizeSelector: _angular_core.InputSignal<boolean>;
    readonly showRangeLabel: _angular_core.InputSignal<boolean>;
    readonly align: _angular_core.InputSignal<PaginatorAlign>;
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Group thousands with commas in the range and page numbers. */
    readonly groupThousands: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly page: _angular_core.ModelSignal<number>;
    readonly pageSize: _angular_core.ModelSignal<number>;
    /** Fires when the user changes either the current page or the page size. */
    readonly changed: _angular_core.OutputEmitterRef<PaginatorState>;
    readonly totalPages: _angular_core.Signal<number>;
    readonly rangeStart: _angular_core.Signal<number>;
    readonly rangeEnd: _angular_core.Signal<number>;
    readonly canGoPrev: _angular_core.Signal<boolean>;
    readonly canGoNext: _angular_core.Signal<boolean>;
    /** Formats a number for display, grouping thousands per the active locale when enabled. */
    protected formatNumber(value: number): string;
    readonly visiblePages: _angular_core.Signal<(number | "ellipsis")[]>;
    /** Navigates to the given page, clamped into the valid range. */
    goToPage(page: number): void;
    /** Navigates to the previous page if one exists. */
    prevPage(): void;
    /** Navigates to the next page if one exists. */
    nextPage(): void;
    onPageSizeChange(event: Event): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaginatorComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaginatorComponent, "ea-paginator", never, { "totalItems": { "alias": "totalItems"; "required": true; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "showPageSizeSelector": { "alias": "showPageSizeSelector"; "required": false; "isSignal": true; }; "showRangeLabel": { "alias": "showRangeLabel"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "groupThousands": { "alias": "groupThousands"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "page": { "alias": "page"; "required": false; "isSignal": true; }; "pageSize": { "alias": "pageSize"; "required": false; "isSignal": true; }; }, { "page": "pageChange"; "pageSize": "pageSizeChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Semantic colour scheme of the progress bar. */
type ProgressBarVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
/** Visual height of the progress bar. */
type ProgressBarSize = EaSize;
/**
 * Linear progress indicator supporting both determinate (driven by `value`
 * and `max`) and indeterminate modes. Optionally renders an inline label
 * and/or the current percentage.
 */
declare class ProgressBarComponent {
    protected readonly i18n: EagamiI18nService;
    readonly value: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly variant: _angular_core.InputSignal<ProgressBarVariant>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Shows the rounded percentage alongside the label. */
    readonly showPercentage: _angular_core.InputSignal<boolean>;
    readonly indeterminate: _angular_core.InputSignal<boolean>;
    /**
     * Optional buffered position ahead of `value` (same scale as `value`),
     * rendered as a secondary-colour segment behind the fill. Use for
     * download/upload-then-process style progress.
     */
    readonly buffer: _angular_core.InputSignal<number | undefined>;
    /** Whether to render the percentage. */
    readonly showsPercentage: _angular_core.Signal<boolean>;
    readonly percentage: _angular_core.Signal<number>;
    readonly percentageRounded: _angular_core.Signal<number>;
    readonly bufferPercentage: _angular_core.Signal<number | null>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-progress-bar--indeterminate': boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ProgressBarComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ProgressBarComponent, "ea-progress-bar", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "showPercentage": { "alias": "showPercentage"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Visual size shared by all radios in the group. */
type RadioSize = EaSize;
/** Layout direction for radios within the group. */
type RadioOrientation = 'vertical' | 'horizontal';
/**
 * Composite single-select control made up of `ea-radio` children. Manages
 * shared state (name, size, disabled) for its options and integrates with
 * Angular forms via `ControlValueAccessor`.
 */
declare class RadioGroupComponent implements ControlValueAccessor {
    readonly id: _angular_core.InputSignal<string>;
    readonly name: _angular_core.InputSignal<string>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly orientation: _angular_core.InputSignal<RadioOrientation>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly value: _angular_core.ModelSignal<string>;
    /** Fires with the new value when an option is selected. */
    readonly changed: _angular_core.OutputEmitterRef<string>;
    private readonly _formDisabled;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    private onChange;
    private onTouched;
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    /** Programmatically selects the option with the given value. */
    select(val: string): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioGroupComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioGroupComponent, "ea-radio-group", never, { "id": { "alias": "id"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "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; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, ["*"], true, never>;
}

/**
 * Single radio option used inside an `ea-radio-group`. Inherits its size and
 * disabled state from the parent group and selecting it updates the group's
 * value.
 */
declare class RadioComponent {
    private readonly group;
    readonly value: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    readonly isChecked: _angular_core.Signal<boolean>;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly name: _angular_core.Signal<string>;
    readonly size: _angular_core.Signal<_eagami_ui.EaSize>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-radio--disabled': boolean;
        'ea-radio--checked': boolean;
    }>;
    handleChange(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioComponent, "ea-radio", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Visual size of the range slider track and thumbs. */
type RangeSliderSize = EaSize;
/** Tuple model emitted by the range slider: `[low, high]`, with `low <= high`. */
type RangeSliderValue = readonly [number, number];
/** Identifies which of the two thumbs an event affects. */
type Thumb = 'low' | 'high';
/**
 * Two-thumb extension of `<ea-slider>`. Drives a `[low, high]` numeric range
 * with pointer drag (the closer thumb to the pointer responds) and full
 * keyboard navigation per thumb (arrows / PageUp / PageDown / Home / End).
 * Tab moves between thumbs. Configurable `min`, `max`, `step`, optional value
 * display, and integrates with Angular forms via `ControlValueAccessor`.
 *
 * Overlap rule: a thumb cannot cross past the other; once it reaches the
 * opposite thumb's position, it clamps to that boundary. Drag-induced
 * overlap (where the user yanks the low thumb past the high) is resolved by
 * keeping the moving thumb on its side and the other thumb pinned.
 */
declare class RangeSliderComponent implements ControlValueAccessor {
    private readonly i18n;
    readonly trackEl: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly min: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly step: _angular_core.InputSignal<number>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly showValue: _angular_core.InputSignal<boolean>;
    readonly showMinMaxLabels: _angular_core.InputSignal<boolean>;
    readonly formatValue: _angular_core.InputSignal<(value: number) => string>;
    /** Group thousands with commas in displayed values (ignored when a custom `formatValue` is set). */
    readonly groupThousands: _angular_core.InputSignal<boolean>;
    /** Accessible label for the low (start) thumb. Falls back to a localized default when omitted. */
    readonly ariaLabelLow: _angular_core.InputSignal<string | undefined>;
    /** Accessible label for the high (end) thumb. Falls back to a localized default when omitted. */
    readonly ariaLabelHigh: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<RangeSliderValue>;
    /** Fires with the new `[low, high]` tuple whenever either thumb moves. */
    readonly changed: _angular_core.OutputEmitterRef<RangeSliderValue>;
    private readonly _formDisabled;
    readonly dragging: _angular_core.WritableSignal<Thumb | null>;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    /** Clamped, ordered `[low, high]` tuple: `low <= high`, both within `[min, max]`. */
    readonly clampedValue: _angular_core.Signal<RangeSliderValue>;
    readonly lowPercent: _angular_core.Signal<number>;
    readonly highPercent: _angular_core.Signal<number>;
    readonly lowThumbLabel: _angular_core.Signal<string>;
    readonly highThumbLabel: _angular_core.Signal<string>;
    readonly lowThumbLabelledBy: _angular_core.Signal<string>;
    readonly highThumbLabelledBy: _angular_core.Signal<string>;
    private thumbLabelledBy;
    /** Formats a value for display, grouping thousands with commas unless a custom `formatValue` is set. */
    protected formatDisplay(value: number): string;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-range-slider--error': boolean;
        'ea-range-slider--disabled': boolean;
        'ea-range-slider--dragging': boolean;
    }>;
    writeValue(val: RangeSliderValue | null | undefined): void;
    registerOnChange(fn: (value: RangeSliderValue) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleKeydown(event: KeyboardEvent, thumb: Thumb): void;
    handleBlur(): void;
    handleTrackPointerDown(event: PointerEvent): void;
    handleTrackPointerMove(event: PointerEvent): void;
    handleTrackPointerUp(event: PointerEvent): void;
    private toPercent;
    private pointerToValue;
    /** Snap to step, clamp to `[min, max]`, then constrain by the opposite thumb. */
    private commitThumb;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RangeSliderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RangeSliderComponent, "ea-range-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "showMinMaxLabels": { "alias": "showMinMaxLabels"; "required": false; "isSignal": true; }; "formatValue": { "alias": "formatValue"; "required": false; "isSignal": true; }; "groupThousands": { "alias": "groupThousands"; "required": false; "isSignal": true; }; "ariaLabelLow": { "alias": "aria-label-low"; "required": false; "isSignal": true; }; "ariaLabelHigh": { "alias": "aria-label-high"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Per-position render state, computed from the current display value. */
type RatingStarState = 'empty' | 'half' | 'full';
/** Visual size of the rating. */
type RatingSize = EaSize;
/**
 * Star-based rating input. Supports whole-star or half-star granularity (via
 * `allowHalf`), hover preview, keyboard navigation (Left/Right/Up/Down,
 * Home/End, 0-9 to jump), and a read-only display mode.
 *
 * The default `<ea-icon-star>` can be swapped via the `iconClass` input
 * (any standalone Angular component reference, e.g. `[iconClass]="HeartIconComponent"`).
 * When `allowHalf` is true, the half-position render uses `halfIconClass`
 * (default `<ea-icon-left-half-star>`); if a consumer supplies their own
 * `iconClass` without a matching `halfIconClass`, the half is rendered with the
 * default left-half-star.
 *
 * Integrates with Angular forms via `ControlValueAccessor`. Emits the new
 * value through the `value` model (numeric 0..max in 1 or 0.5 increments).
 */
declare class RatingComponent implements ControlValueAccessor {
    constructor();
    private readonly starsEl;
    protected readonly i18n: EagamiI18nService;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly min: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly allowHalf: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    /** Clicking the current value clears the rating back to 0. */
    readonly clearable: _angular_core.InputSignal<boolean>;
    /** Standalone component class rendered for empty / full positions. */
    readonly iconClass: _angular_core.InputSignal<Type<unknown>>;
    /** Standalone component class rendered for half positions (when `allowHalf` is true). */
    readonly halfIconClass: _angular_core.InputSignal<Type<unknown>>;
    readonly id: _angular_core.InputSignal<string>;
    /** Current rating value, 0..max in 1 (or 0.5 when `allowHalf`) increments. */
    readonly value: _angular_core.ModelSignal<number>;
    /** Fires when the user pre-selects a value via hover; `null` when the cursor leaves. */
    readonly hoverChanged: _angular_core.OutputEmitterRef<number | null>;
    protected readonly hoverValue: _angular_core.WritableSignal<number | null>;
    protected readonly isFocused: _angular_core.WritableSignal<boolean>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    protected readonly isDisabled: _angular_core.Signal<boolean>;
    protected readonly isInteractive: _angular_core.Signal<boolean>;
    private readonly errorState;
    protected readonly errorText: _angular_core.Signal<string | null>;
    protected readonly hasError: _angular_core.Signal<boolean>;
    protected readonly showError: _angular_core.Signal<boolean>;
    protected readonly showHint: _angular_core.Signal<boolean>;
    protected readonly step: _angular_core.Signal<1 | 0.5>;
    /** Value used to render the stars (hover preview wins over committed value). */
    protected readonly displayValue: _angular_core.Signal<number>;
    /** 1..max positions for the @for loop. */
    protected readonly positions: _angular_core.Signal<number[]>;
    protected readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-rating-field--error': boolean;
        'ea-rating-field--disabled': boolean;
        'ea-rating-field--readonly': boolean;
        'ea-rating-field--focused': boolean;
    }>;
    protected readonly errorId: _angular_core.Signal<string>;
    protected readonly hintId: _angular_core.Signal<string>;
    protected readonly describedBy: _angular_core.Signal<string | null>;
    protected readonly resolvedAriaLabel: _angular_core.Signal<string>;
    /** Resolves the render state for star `pos` against the current display value. */
    protected stateFor(pos: number): RatingStarState;
    /** Component class to instantiate for star `pos`. */
    protected iconForState(state: RatingStarState): Type<unknown>;
    protected starAriaLabel(pos: number): string;
    writeValue(value: number | null | undefined): void;
    registerOnChange(fn: (value: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    protected onPointerMove(event: PointerEvent, pos: number): void;
    protected onPointerLeave(): void;
    protected onClick(event: MouseEvent, pos: number): void;
    protected onFocus(): void;
    protected onBlur(): void;
    protected onKeydown(event: KeyboardEvent): void;
    private commit;
    private clamp;
    private computePointerValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RatingComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RatingComponent, "ea-rating", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "allowHalf": { "alias": "allowHalf"; "required": false; "isSignal": true; }; "readonly": { "alias": "readonly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; "halfIconClass": { "alias": "halfIconClass"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "hoverChanged": "hoverChanged"; }, never, never, true, never>;
}

/** Visual size of the segmented control. */
type SegmentedSize = EaSize;
/**
 * Compact toggle button group for picking one of a small set of options
 * (e.g. List/Grid/Kanban or Light/Dark). Implements `radiogroup` semantics
 * and `ControlValueAccessor`, with full keyboard support
 * (arrow keys, Home/End, Enter/Space).
 */
declare class SegmentedComponent implements ControlValueAccessor {
    readonly buttonEls: _angular_core.Signal<readonly ElementRef<HTMLButtonElement>[]>;
    readonly options: _angular_core.InputSignal<SelectOption[]>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly fullWidth: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<string>;
    /** Fires with the new value when the user selects a different option. */
    readonly changed: _angular_core.OutputEmitterRef<string>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly enabledOptions: _angular_core.Signal<SelectOption[]>;
    readonly firstEnabledIndex: _angular_core.Signal<number>;
    readonly tabStopIndex: _angular_core.Signal<number>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-segmented--full-width': boolean;
        'ea-segmented--disabled': boolean;
        'ea-segmented--error': boolean;
    }>;
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    isSelected(option: SelectOption): boolean;
    isOptionDisabled(option: SelectOption): boolean;
    /** Programmatically selects the given option. */
    select(option: SelectOption): void;
    handleKeydown(event: KeyboardEvent, index: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SegmentedComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SegmentedComponent, "ea-segmented", never, { "options": { "alias": "options"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Shape preset of a skeleton placeholder. */
type SkeletonVariant = 'text' | 'circle' | 'rect';
/**
 * Loading placeholder rendered as a pulsing block in one of three shapes.
 * Honours `prefers-reduced-motion` by suppressing the pulse animation when
 * the user has expressed that preference.
 */
declare class SkeletonComponent {
    readonly variant: _angular_core.InputSignal<SkeletonVariant>;
    readonly width: _angular_core.InputSignal<string | undefined>;
    readonly height: _angular_core.InputSignal<string | undefined>;
    readonly animated: _angular_core.InputSignal<boolean>;
    readonly hostStyles: _angular_core.Signal<Record<string, string>>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-skeleton--animated': boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkeletonComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkeletonComponent, "ea-skeleton", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "animated": { "alias": "animated"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Visual size of the slider track and thumb. */
type SliderSize = EaSize;
declare class SliderComponent implements ControlValueAccessor {
    private readonly i18n;
    readonly trackEl: _angular_core.Signal<ElementRef<HTMLDivElement> | undefined>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Force the error-state styling without binding `errorMsg`. Lets consumers
     *  render the error text themselves (e.g. above the slider in a form layout)
     *  while still getting the built-in recolour of the fill and thumb. */
    readonly hasError: _angular_core.InputSignal<boolean>;
    readonly min: _angular_core.InputSignal<number>;
    readonly max: _angular_core.InputSignal<number>;
    readonly step: _angular_core.InputSignal<number>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly showValue: _angular_core.InputSignal<boolean>;
    readonly showMinMaxLabels: _angular_core.InputSignal<boolean>;
    readonly formatValue: _angular_core.InputSignal<(value: number) => string>;
    /**
     * Values the thumb is pulled onto while dragging, each drawn as a tick on
     * the track. The pull reaches a few pixels either side, so a marked value
     * can be landed exactly without hunting for it.
     */
    readonly snapValues: _angular_core.InputSignal<readonly number[]>;
    /** Group thousands with commas in displayed values (ignored when a custom `formatValue` is set). */
    readonly groupThousands: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<number>;
    /** Fires with the new (snapped, clamped) numeric value whenever the slider moves. */
    readonly changed: _angular_core.OutputEmitterRef<number>;
    private readonly _formDisabled;
    readonly dragging: _angular_core.WritableSignal<boolean>;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    readonly clampedValue: _angular_core.Signal<number>;
    readonly percent: _angular_core.Signal<number>;
    /** Where each snap value's tick sits along the track. */
    readonly tickPercents: _angular_core.Signal<number[]>;
    /** Formats a value for display, grouping thousands with commas unless a custom `formatValue` is set. */
    protected formatDisplay(value: number): string;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly errored: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-slider--error': boolean;
        'ea-slider--disabled': boolean;
        'ea-slider--dragging': boolean;
    }>;
    writeValue(val: number): void;
    registerOnChange(fn: (value: number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleKeydown(event: KeyboardEvent): void;
    handlePointerDown(event: PointerEvent): void;
    handlePointerMove(event: PointerEvent): void;
    handlePointerUp(event: PointerEvent): void;
    handleBlur(): void;
    private updateFromPointer;
    /** The snap value within the magnet's reach of the pointer, if any. */
    private magnetTarget;
    private commitValue;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SliderComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SliderComponent, "ea-slider", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "hasError": { "alias": "hasError"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "showValue": { "alias": "showValue"; "required": false; "isSignal": true; }; "showMinMaxLabels": { "alias": "showMinMaxLabels"; "required": false; "isSignal": true; }; "formatValue": { "alias": "formatValue"; "required": false; "isSignal": true; }; "snapValues": { "alias": "snapValues"; "required": false; "isSignal": true; }; "groupThousands": { "alias": "groupThousands"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Visual size of the spinner. */
type SpinnerSize = EaSize;
/**
 * SVG loading indicator with an accessible `role="status"`. The `label` input
 * overrides the accessible name announced to assistive technology; when unset
 * it falls back to the active locale's translation.
 */
declare class SpinnerComponent {
    private readonly i18n;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Accessible label, falling back to the active locale's translation. */
    readonly resolvedLabel: _angular_core.Signal<string>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpinnerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpinnerComponent, "ea-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * Single step within an `<ea-stepper>`. Registers itself with the parent on
 * init, exposes its `label` / `completed` / `optional` flags, and shows its
 * projected content when active.
 */
declare class StepComponent implements OnInit, OnDestroy {
    private readonly stepper;
    readonly label: _angular_core.InputSignal<string>;
    readonly completed: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly optional: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    readonly isActive: _angular_core.Signal<boolean>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepComponent, "ea-step", never, { "label": { "alias": "label"; "required": true; "isSignal": true; }; "completed": { "alias": "completed"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "optional": { "alias": "optional"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/** Visual size of the stepper. */
type StepperSize = EaSize;
/** Axis the steps are laid out along. */
type StepperOrientation = 'horizontal' | 'vertical';
/**
 * Multi-step navigation paired with content panels. Child `<ea-step>`
 * components register themselves automatically and the active panel is
 * shown based on the `activeStep` (zero-based index) two-way binding.
 *
 * In `linear` mode, steps cannot be navigated to until all earlier
 * non-optional steps are marked `completed`. Otherwise any step can be
 * clicked. ArrowLeft / ArrowRight walk through reachable steps; Home/End
 * jump to the extremes.
 */
declare class StepperComponent {
    protected readonly i18n: EagamiI18nService;
    readonly registeredSteps: _angular_core.WritableSignal<StepComponent[]>;
    readonly activeStep: _angular_core.ModelSignal<number>;
    readonly linear: _angular_core.InputSignal<boolean>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly orientation: _angular_core.InputSignal<StepperOrientation>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    /** Fires with the new active step index when the user navigates. */
    readonly changed: _angular_core.OutputEmitterRef<number>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-stepper--disabled': boolean;
    }>;
    registerStep(step: StepComponent): void;
    unregisterStep(step: StepComponent): void;
    /** Returns the index of a given step, or `-1` if it isn't registered. */
    indexOf(step: StepComponent): number;
    /**
     * True when the user can navigate directly to the step at `index`. In
     * non-linear mode this is true for any non-disabled step; in linear mode,
     * every non-optional earlier step must also be marked `completed`.
     */
    canNavigateTo(index: number): boolean;
    /** Activate the step at `index` if reachable. */
    selectStep(index: number): void;
    handleKeydown(event: KeyboardEvent): void;
    private nextReachable;
    private firstReachable;
    private lastReachable;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepperComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepperComponent, "ea-stepper", never, { "activeStep": { "alias": "activeStep"; "required": false; "isSignal": true; }; "linear": { "alias": "linear"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, { "activeStep": "activeStepChange"; "changed": "changed"; }, never, ["*"], true, never>;
}

/** Visual size of the switch. */
type SwitchSize = EaSize;
/**
 * On/off toggle styled as a sliding switch. Backed by a visually hidden
 * native checkbox and integrates with Angular forms via
 * `ControlValueAccessor`.
 */
declare class SwitchComponent implements ControlValueAccessor {
    readonly label: _angular_core.InputSignal<string | undefined>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly checked: _angular_core.ModelSignal<boolean>;
    /** Fires with the new checked state whenever the user toggles the switch. */
    readonly changed: _angular_core.OutputEmitterRef<boolean>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-switch--checked': boolean;
        'ea-switch--disabled': boolean;
        'ea-switch--error': boolean;
    }>;
    writeValue(val: boolean): void;
    registerOnChange(fn: (value: boolean) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleChange(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SwitchComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SwitchComponent, "ea-switch", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "checked": { "alias": "checked"; "required": false; "isSignal": true; }; }, { "checked": "checkedChange"; "changed": "changed"; }, never, never, true, never>;
}

/**
 * Single tab within an `ea-tabs` group. Registers itself with the parent on
 * init, exposes its `value` and `label`, and shows its projected content
 * when active.
 */
declare class TabComponent implements OnInit, OnDestroy {
    private readonly tabs;
    readonly value: _angular_core.InputSignal<string>;
    readonly label: _angular_core.InputSignal<string>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly id: _angular_core.InputSignal<string>;
    readonly isActive: _angular_core.Signal<boolean>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabComponent, "ea-tab", never, { "value": { "alias": "value"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
}

/** Visual style of the tab bar. */
type TabsVariant = 'underline' | 'filled';
/** Visual size of the tabs. */
type TabsSize = EaSize;
/**
 * Tab bar paired with content panels. Child `ea-tab` components register
 * themselves automatically and the active panel is shown based on the
 * `activeTab` two-way binding. Supports keyboard navigation
 * (arrow keys, Home/End).
 */
declare class TabsComponent {
    readonly registeredTabs: _angular_core.WritableSignal<TabComponent[]>;
    readonly variant: _angular_core.InputSignal<TabsVariant>;
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Accessible name for the tablist, announced by screen readers. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly activeTab: _angular_core.ModelSignal<string>;
    /** Fires with the value of the newly active tab. */
    readonly changed: _angular_core.OutputEmitterRef<string>;
    /** Registers a child tab so it appears in the tab bar; called automatically by `ea-tab`. */
    registerTab(tab: TabComponent): void;
    /** Removes a previously registered child tab; called automatically by `ea-tab`. */
    unregisterTab(tab: TabComponent): void;
    /** Programmatically activates the tab with the given value. */
    selectTab(value: string): void;
    handleKeydown(event: KeyboardEvent): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabsComponent, "ea-tabs", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "activeTab": { "alias": "activeTab"; "required": false; "isSignal": true; }; }, { "activeTab": "activeTabChange"; "changed": "changed"; }, never, ["*"], true, never>;
}

/** Placement of the tooltip relative to its host element. */
type TooltipPosition = 'top' | 'bottom' | 'left' | 'right';
/**
 * Attaches a positioned tooltip to its host element. Shows on hover and
 * focus, hides on leave/blur or Escape (a blur while the pointer is still on
 * the trigger keeps the bubble open), and wires up `aria-describedby` so
 * the tooltip text is announced to assistive technology. Accepts either a
 * plain string or a `TemplateRef` for styled multi-part content. Binding an
 * empty string suppresses the bubble, which is how a host shows one only in
 * some states (a label that is currently truncated, say).
 *
 * The directive listens on `focusin`, not `focus`, so it fires for a focusable
 * descendant of the host as well as the host itself. A host listener paired
 * with `eaTooltip` has to use `focusin` for the same reason: `focus` does not
 * bubble, so it never fires when the focus lands on a child.
 *
 * Bubbles never grow past the viewport: they clamp to it, minus
 * `--ea-tooltip-viewport-margin` on each side, and scroll whatever the clamp
 * cuts off. A clamped bubble takes pointer events so that scrollbar is
 * reachable, which also means it waits `dismissDelay` before hiding rather than
 * going the moment the pointer leaves the trigger. Bubbles that fit stay
 * display-only.
 */
declare class TooltipDirective implements OnDestroy {
    private readonly el;
    private readonly renderer;
    private readonly viewContainer;
    readonly eaTooltip: _angular_core.InputSignal<string | TemplateRef<unknown>>;
    readonly tooltipPosition: _angular_core.InputSignal<TooltipPosition>;
    /**
     * Whether a bubble with no room on the requested side moves to the opposite
     * one. The side is resolved when the bubble opens and held while it still
     * fits, so a bubble does not hop across its trigger mid-hover.
     */
    readonly flip: _angular_core.InputSignal<boolean>;
    /**
     * Show only while the trigger is cutting its own content off, which is how a
     * label that ellipsizes reveals its full text without a bubble on every
     * label that fits. The whole subtree is measured, since the box doing the
     * cutting is usually an inner one.
     */
    readonly whenClipped: _angular_core.InputSignal<boolean>;
    /**
     * Max width in px; the text wraps at this width. Clamped to a 50px floor, and
     * to the viewport, which no value can push the bubble past.
     */
    readonly maxWidth: _angular_core.InputSignal<number | undefined>;
    /**
     * Grace period in ms before a bubble the viewport clamp made scrollable hides
     * after the pointer leaves, long enough to cross the gap onto the bubble and
     * reach its scrollbar. Bubbles that fit hide immediately.
     */
    readonly dismissDelay: _angular_core.InputSignal<number>;
    private tooltipEl;
    /** Side the open bubble settled on, held across repositions while it fits. */
    private placedPosition;
    private templateView;
    private scrollable;
    private hideTimer;
    private pointerInside;
    private readonly tooltipId;
    private readonly hoverMql;
    private readonly showHandler;
    private readonly pointerLeaveHandler;
    private readonly hideHandler;
    private readonly focusoutHandler;
    private readonly bubbleEnterHandler;
    private readonly supportsFocusVisible;
    private readonly focusHandler;
    private readonly keydownHandler;
    private readonly hoverChangeHandler;
    private rafId;
    private readonly repositionHandler;
    private readonly relayoutHandler;
    private readonly scrollListenerOptions;
    private resizeObserver;
    constructor();
    ngOnDestroy(): void;
    private syncPointerListeners;
    private show;
    private shrinkToContent;
    private requestHide;
    private cancelPendingHide;
    private hide;
    private attachRepositionListeners;
    private detachRepositionListeners;
    private appendDescribedBy;
    private removeDescribedBy;
    private positionTooltip;
    private applyPlacedPosition;
    private viewportMargin;
    private syncScrollable;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TooltipDirective, never>;
    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<TooltipDirective, "[eaTooltip]", never, { "eaTooltip": { "alias": "eaTooltip"; "required": true; "isSignal": true; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; "isSignal": true; }; "flip": { "alias": "flip"; "required": false; "isSignal": true; }; "whenClipped": { "alias": "whenClipped"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "dismissDelay": { "alias": "dismissDelay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Semantic colour scheme of a tag. */
type TagVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
/** Visual size of a tag. */
type TagSize = EaSize;
/** Where a clipped label reveals its full text, or `none` to suppress it. */
type TagTooltip = 'above' | 'below' | 'none';
/**
 * Inline label commonly used to represent filters, categories, or selected
 * items. When `removable`, renders a close button that emits `removed`; the
 * accessible name of that button is configurable via `removeLabel` and
 * otherwise falls back to the active locale's translation.
 *
 * When capped by `maxWidth` (or the `--ea-tag-max-width` custom property),
 * the projected label ellipsizes rather than widening the chip, revealing its
 * full text in a tooltip while it is clipped.
 */
declare class TagComponent {
    private readonly i18n;
    private readonly destroyRef;
    private readonly labelEl;
    readonly variant: _angular_core.InputSignal<TagVariant>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly removable: _angular_core.InputSignal<boolean>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly removeLabel: _angular_core.InputSignal<string | undefined>;
    /**
     * Widest the chip may grow: a number of px, or any CSS length for a chip that
     * has to give way to its container (`'100%'` in a responsive grid cell).
     * Also settable in CSS as `--ea-tag-max-width`, which this input overrides.
     */
    readonly maxWidth: _angular_core.InputSignal<string | number | undefined>;
    /**
     * Fill colour as a hex value, for a tag carrying a colour of its own (a
     * user-chosen label). Paints the chip and its border, and picks whichever ink
     * reads better on it. Takes precedence over `variant`.
     */
    readonly color: _angular_core.InputSignal<string | undefined>;
    /**
     * Where a label clipped by `maxWidth` reveals its full text. Set `none` for
     * a tag rendered inside a tooltip, which would otherwise stack a second
     * bubble over the first.
     */
    readonly tooltip: _angular_core.InputSignal<TagTooltip>;
    /**
     * Whether the remove button is a tab stop. Set `false` inside a composite
     * widget (a combobox trigger, a grid cell) whose own keyboard model owns
     * navigation, since roles like `combobox` forbid focusable descendants.
     */
    readonly removeTabbable: _angular_core.InputSignal<boolean>;
    readonly uppercase: _angular_core.InputSignal<boolean>;
    /** Fires when the user activates the remove button on a `removable` tag. */
    readonly removed: _angular_core.OutputEmitterRef<void>;
    /** Full label text, held only while the rendered label is clipped. */
    private readonly clippedText;
    /** Accessible label for the remove button, falling back to the active locale. */
    readonly resolvedRemoveLabel: _angular_core.Signal<string>;
    /** Tooltip text for the label; empty suppresses the bubble entirely. */
    protected readonly labelTooltip: _angular_core.Signal<string>;
    protected readonly tooltipPosition: _angular_core.Signal<TooltipPosition>;
    readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-tag--disabled': boolean;
        'ea-tag--uppercase': boolean;
    }>;
    /** `maxWidth` as a CSS length; a bare number is px, as the input documents. */
    protected readonly resolvedMaxWidth: _angular_core.Signal<string | null>;
    /** Ink that reads on `color`, or `null` when it is not a hex the library can measure. */
    protected readonly resolvedInk: _angular_core.Signal<string | null>;
    protected readonly resolvedColor: _angular_core.Signal<string | null>;
    constructor();
    onRemove(event: MouseEvent): void;
    /**
     * Keeps `clippedText` in step with the rendered label. Size and text are
     * watched separately because a capped chip holds its width when the text
     * behind the ellipsis changes, so a resize alone would leave stale text.
     */
    private watchLabel;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagComponent, "ea-tag", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removeLabel": { "alias": "removeLabel"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; "color": { "alias": "color"; "required": false; "isSignal": true; }; "tooltip": { "alias": "tooltip"; "required": false; "isSignal": true; }; "removeTabbable": { "alias": "removeTabbable"; "required": false; "isSignal": true; }; "uppercase": { "alias": "uppercase"; "required": false; "isSignal": true; }; }, { "removed": "removed"; }, never, ["*"], true, never>;
}

/** Visual size of the textarea. */
type TextareaSize = EaSize;
/** Axis along which the user is allowed to resize the textarea. */
type TextareaResize = 'none' | 'vertical' | 'horizontal' | 'both';
/**
 * Multiline text field that mirrors the `ea-input` API. Supports configurable
 * `resize` direction and `maxlength`, and integrates with Angular
 * forms via `ControlValueAccessor`.
 */
declare class TextareaComponent implements ControlValueAccessor {
    readonly textareaEl: _angular_core.Signal<ElementRef<HTMLTextAreaElement> | undefined>;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    /** Accessible name for the control when no visible `label` is set. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly placeholder: _angular_core.InputSignal<string>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly resize: _angular_core.InputSignal<TextareaResize>;
    readonly maxlength: _angular_core.InputSignal<number | undefined>;
    /** Optional pixel ceiling for the textarea's height. Beyond it, the inner
     * field scrolls vertically instead of growing. */
    readonly maxHeight: _angular_core.InputSignal<number | undefined>;
    /** Optional pixel floor for the textarea's height. Clamped so it never drops
     * below the default height. */
    readonly minHeight: _angular_core.InputSignal<number | undefined>;
    readonly id: _angular_core.InputSignal<string>;
    readonly value: _angular_core.ModelSignal<string>;
    readonly isFocused: _angular_core.WritableSignal<boolean>;
    private readonly _formDisabled;
    /** Fires when the textarea receives focus. */
    readonly focused: _angular_core.OutputEmitterRef<FocusEvent>;
    /** Fires when the textarea loses focus. */
    readonly blurred: _angular_core.OutputEmitterRef<FocusEvent>;
    private onChange;
    private onTouched;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-textarea-wrapper--error': boolean;
        'ea-textarea-wrapper--focused': boolean;
        'ea-textarea-wrapper--disabled': boolean;
        'ea-textarea-wrapper--readonly': boolean;
    }>;
    readonly minHeightStyle: _angular_core.Signal<string>;
    writeValue(val: string): void;
    registerOnChange(fn: (value: string) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    handleInput(event: Event): void;
    handleFocus(event: FocusEvent): void;
    handleBlur(event: FocusEvent): void;
    /** Moves keyboard focus to the underlying native textarea element. */
    focus(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TextareaComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TextareaComponent, "ea-textarea", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "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; }; "resize": { "alias": "resize"; "required": false; "isSignal": true; }; "maxlength": { "alias": "maxlength"; "required": false; "isSignal": true; }; "maxHeight": { "alias": "maxHeight"; "required": false; "isSignal": true; }; "minHeight": { "alias": "minHeight"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "focused": "focused"; "blurred": "blurred"; }, never, never, true, never>;
}

/** Visual size of the time picker trigger. */
type TimePickerSize = EaSize;
/** Display format for the trigger label. The wire value is always 24h. */
type TimePickerFormat = '12h' | '24h';
/** Internal identifier for the three unit columns. */
type Unit = 'hours' | 'minutes' | 'seconds';
interface ParsedTime {
    readonly hours: number;
    readonly minutes: number;
    readonly seconds: number;
}
/**
 * Pops a stepper UI for selecting an `HH:MM[:SS]` time. The wire value is
 * always a 24-hour string (`"14:30"` or `"14:30:00"`); the `format` input
 * toggles the trigger's display between 12-hour and 24-hour styles. Supports
 * configurable steps for minutes and seconds, optional seconds column, and
 * integrates with Angular forms via `ControlValueAccessor`.
 *
 * The field itself is a text input: a time can be typed by hand and is read
 * leniently on Enter or blur. Bare digits are a 24-hour clock ("5" is 05:00,
 * "1234" is 12:34, "123456" adds seconds), `:`, `.`, `h`, and spaces all
 * separate units ("17h30", "12.34"), and an AM/PM suffix reads the hour on
 * the 12-hour clock ("5pm" is 17:00). Text that parses to no time is
 * discarded and the field falls back to the current value; clearing the text
 * clears the value.
 *
 * Keyboard: ArrowDown opens the popover and moves into the hour column. Tab
 * moves between the hour, minute, (seconds), and AM/PM columns. Each spinner
 * accepts ArrowUp/ArrowDown to step by 1 (or by the configured step),
 * PageUp/PageDown for a coarser bump, and digit keys to type a value
 * directly. After typing two digits (or one digit that already maxes the
 * unit), focus auto-advances to the next column. Backspace clears the typed
 * buffer; Escape closes the popover.
 */
declare class TimePickerComponent implements ControlValueAccessor {
    protected readonly triggerEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    protected readonly inputEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    protected readonly hoursEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    protected readonly minutesEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    protected readonly secondsEl: _angular_core.Signal<ElementRef<HTMLInputElement> | undefined>;
    protected readonly i18n: EagamiI18nService;
    private readonly destroyRef;
    private readonly injector;
    readonly label: _angular_core.InputSignal<string | undefined>;
    /** Optional icon component rendered before the label text. */
    readonly labelIcon: _angular_core.InputSignal<Type<unknown> | undefined>;
    readonly placeholder: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    readonly readonly: _angular_core.InputSignal<boolean>;
    readonly required: _angular_core.InputSignal<boolean>;
    readonly hint: _angular_core.InputSignal<string | undefined>;
    readonly errorMsg: _angular_core.InputSignal<string | undefined>;
    /** Per-validator-key message overrides for a bound form control (e.g. `{ required: '...' }`). */
    readonly errorMessages: _angular_core.InputSignal<Partial<Record<string, string>> | undefined>;
    /** Display format for the trigger label. Wire value is always 24h. */
    readonly format: _angular_core.InputSignal<TimePickerFormat>;
    readonly includeSeconds: _angular_core.InputSignal<boolean>;
    readonly minuteStep: _angular_core.InputSignal<number>;
    readonly secondStep: _angular_core.InputSignal<number>;
    readonly id: _angular_core.InputSignal<string>;
    readonly popoverId: _angular_core.Signal<string>;
    /** `"HH:MM"` or `"HH:MM:SS"` in 24-hour notation, or `null` when unset. */
    readonly value: _angular_core.ModelSignal<string | null>;
    /** Fires with the new value whenever the user changes the time. */
    readonly changed: _angular_core.OutputEmitterRef<string | null>;
    readonly isOpen: _angular_core.WritableSignal<boolean>;
    /** Raw text under edit in the field, or `null` while it mirrors the value. */
    readonly typedText: _angular_core.WritableSignal<string | null>;
    /** Typed-digit buffer for the currently focused column, or `null` when idle. */
    readonly editBuffer: _angular_core.WritableSignal<{
        unit: Unit;
        digits: string;
    } | null>;
    private readonly _formDisabled;
    private onChange;
    private onTouched;
    /** Long-press timers for the chevron buttons. Cleared on release/destroy. */
    private holdDelayTimer;
    private holdIntervalTimer;
    private holdStartedAt;
    readonly isDisabled: _angular_core.Signal<boolean>;
    private readonly errorState;
    readonly errorText: _angular_core.Signal<string | null>;
    readonly hasError: _angular_core.Signal<boolean>;
    readonly showError: _angular_core.Signal<boolean>;
    readonly showHint: _angular_core.Signal<boolean>;
    /** Parsed `[hh, mm, ss]` from the current value, defaulting to midnight. */
    readonly parsed: _angular_core.Signal<ParsedTime>;
    /** True when the picker has a non-null value. Drives the clear button + placeholder fallback. */
    readonly hasValue: _angular_core.Signal<boolean>;
    /** Hours digit displayed in the popover stepper. Honors the `format` input. */
    readonly displayHours: _angular_core.Signal<number>;
    /**
     * Text shown in a column's value cell. Reflects the typed-digit buffer when
     * the user is mid-edit on that column; otherwise renders the committed
     * value. Hours pad to two digits in 24h mode only (so 9 AM still reads as
     * "9", but 09:00 in 24h reads as "09").
     */
    hoursText: _angular_core.Signal<string>;
    minutesText: _angular_core.Signal<string>;
    secondsText: _angular_core.Signal<string>;
    /** `'AM' | 'PM'` for 12h mode; `null` in 24h. */
    readonly period: _angular_core.Signal<"AM" | "PM" | null>;
    /** Localized text shown on the trigger. Falls back to placeholder when no value. */
    readonly displayValue: _angular_core.Signal<string | null>;
    readonly resolvedPlaceholder: _angular_core.Signal<string>;
    /** What the field's input shows: the text mid-edit, else the formatted value. */
    readonly triggerText: _angular_core.Signal<string>;
    readonly triggerClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-time-picker__trigger--error': boolean;
        'ea-time-picker__trigger--open': boolean;
        'ea-time-picker__trigger--disabled': boolean;
        'ea-time-picker__trigger--readonly': boolean;
    }>;
    readonly wrapperClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    readonly popoverClasses: _angular_core.Signal<{
        [x: string]: boolean;
    }>;
    writeValue(val: string | null | undefined): void;
    registerOnChange(fn: (value: string | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    constructor();
    /**
     * A click anywhere on the field opens the popover and leaves the focus in
     * the input, so the caret lands where it was aimed and typing can start
     * straight away. A click while open only moves the caret.
     */
    onTriggerClick(): void;
    /**
     * Push focus into the hours input once the popover surface has been
     * rendered. `afterNextRender` guarantees the DOM has been updated (and the
     * surface is no longer `display: none`) before we call `.focus()`.
     */
    private focusHoursWhenReady;
    close(): void;
    /** Called by `<ea-popover>` when the user clicks outside or scrolls. */
    onPopoverCloseRequested(): void;
    clear(event: Event): void;
    handleTriggerKeydown(event: KeyboardEvent): void;
    onTriggerInput(event: Event): void;
    onTriggerBlur(): void;
    /**
     * Reads the hand-typed text and commits what it says: a time updates the
     * value, emptied text clears it, and anything unreadable is dropped so the
     * field falls back to the value it already shows.
     */
    private commitTyped;
    /** Stepper button or keyboard arrow nudges one column up or down. */
    step(unit: Unit, direction: 1 | -1): void;
    /**
     * Keyboard activation of a stepper button dispatches only a click, never the
     * pointer events that drive the hold repeat. `detail` is 0 for those
     * synthetic clicks, so pointer presses (already handled by startHold) are
     * ignored here.
     */
    onStepClick(unit: Unit, direction: 1 | -1, event: MouseEvent): void;
    /**
     * Begin a long-press repeat on a chevron button. Fires once immediately,
     * then after a `HOLD_INITIAL_DELAY` pause repeats at `HOLD_INTERVAL_MS`,
     * accelerating to `HOLD_FAST_INTERVAL_MS` after `HOLD_ACCELERATE_AFTER_MS`
     * of continuous holding. Pointer up / leave / cancel stops the repeat.
     */
    startHold(unit: Unit, direction: 1 | -1, event: Event): void;
    /** End any in-flight long-press repeat. Idempotent. */
    stopHold(): void;
    /** Switches the AM/PM period in 12h mode by toggling the 12-hour offset. */
    togglePeriod(): void;
    handlePopoverKeydown(event: KeyboardEvent, unit: Unit): void;
    /** Escape from anywhere inside the popover closes it and refocuses the field. */
    onPopoverEscape(event: Event): void;
    /** Select-all on focus so the first keystroke replaces the current value. */
    onSpinnerFocus(event: FocusEvent): void;
    /**
     * Native `(input)` event: the typed value is already in `el.value`. Strip
     * non-digits, update the buffer (which drives the displayed text), and
     * commit + auto-advance once the column is full or a third digit would
     * overflow.
     */
    onSpinnerInput(unit: Unit, event: Event): void;
    /** Commits the current buffer if any. Wired to each input's `(blur)`. */
    onSpinnerBlur(): void;
    /** True when no digit `0`–`9` can validly extend the current buffer. */
    private cannotExtend;
    /** Commits any pending buffer. Called on blur, on arrow keys, on Tab. */
    private flushBuffer;
    /** Writes the buffered digits into the value and clears the buffer. */
    private commitDigits;
    /**
     * Map a typed hours value back to 24h. In 24h mode the typed value is the
     * hour. In 12h mode the typed value is interpreted in the current period
     * (AM: 12 maps to 0, others stay; PM: 12 stays, others add 12).
     */
    private hoursFromTyped;
    private minFor;
    private maxFor;
    /** Move focus to the next unit column, looping back to hours at the end. */
    private advanceFocus;
    private nextUnit;
    private commit;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimePickerComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimePickerComponent, "ea-time-picker", never, { "label": { "alias": "label"; "required": false; "isSignal": true; }; "labelIcon": { "alias": "labelIcon"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "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; }; "hint": { "alias": "hint"; "required": false; "isSignal": true; }; "errorMsg": { "alias": "errorMsg"; "required": false; "isSignal": true; }; "errorMessages": { "alias": "errorMessages"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "includeSeconds": { "alias": "includeSeconds"; "required": false; "isSignal": true; }; "minuteStep": { "alias": "minuteStep"; "required": false; "isSignal": true; }; "secondStep": { "alias": "secondStep"; "required": false; "isSignal": true; }; "id": { "alias": "id"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; "changed": "changed"; }, never, never, true, never>;
}

/** Direction the timeline flows. */
type TimelineOrientation = 'vertical' | 'horizontal';
/**
 * Placement of each item's content relative to the line. `alternate` zig-zags
 * items to either side of a centered line and applies to vertical timelines only.
 */
type TimelineAlign = 'start' | 'alternate';
/** Semantic color of a timeline item's node. */
type TimelineItemColor = 'default' | 'primary' | 'secondary' | 'success' | 'warning' | 'error';
/** Visual size of the timeline. */
type TimelineSize = EaSize;
/** Single event rendered in an `<ea-timeline>`. */
interface TimelineItem {
    /** Title line for the event. */
    heading?: string;
    /** Muted meta line, typically a timestamp. */
    time?: string;
    /** Body text describing the event. */
    description?: string;
    /** Node color; ignored when `current` is set. */
    color?: TimelineItemColor;
    /** Marks the current point in time; the node wears the secondary brand and a halo. */
    current?: boolean;
}
/**
 * Vertical or horizontal sequence of events, each a colored node on a connecting
 * line with an optional heading, timestamp, and description. A single item flagged
 * `current` is highlighted with the secondary brand color to mark "you are here".
 */
declare class TimelineComponent {
    /** The events to render, in order. */
    readonly items: _angular_core.InputSignal<TimelineItem[]>;
    /** Direction the timeline flows. */
    readonly orientation: _angular_core.InputSignal<TimelineOrientation>;
    /** Content placement relative to the line; `alternate` applies to vertical timelines only. */
    readonly align: _angular_core.InputSignal<TimelineAlign>;
    /** Visual size; scales nodes, gaps, and text from a single knob. */
    readonly size: _angular_core.InputSignal<EaSize>;
    protected readonly hostClasses: _angular_core.Signal<{
        [x: string]: boolean;
        'ea-timeline--alternate': boolean;
    }>;
    protected itemModifier(item: TimelineItem): string;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimelineComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimelineComponent, "ea-timeline", never, { "items": { "alias": "items"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/** Semantic colour scheme of a toast. */
type ToastVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
/** One run of a toast's title or message. */
interface ToastSegment {
    text: string;
    /** Drawn at full strength, for the part the reader is meant to catch. */
    strong?: boolean;
}
/**
 * A toast's title or message: a plain string, or segments so the parts worth
 * catching (a name, a count) can be emphasized. Segments are bound as text and
 * rendered in order with nothing between them, so they read as one sentence.
 */
type ToastText = string | readonly ToastSegment[];
/** A single live toast notification rendered by `ea-toast`. */
interface Toast {
    id: number;
    message: ToastText;
    /** Heading shown above the message; the message steps back when set. */
    title?: ToastText;
    variant: ToastVariant;
    duration: number;
    /** Icon component rendered in place of the variant's own; `null` renders none. */
    icon?: Type<unknown> | null;
}
/** Optional configuration for a toast; defaults to `default` variant and 4s duration. */
interface ToastOptions {
    /** Heading shown above the message; the message steps back when set. */
    title?: ToastText;
    variant?: ToastVariant;
    duration?: number;
    /** Any icon component to render in place of the variant's own; `null` for no icon. */
    icon?: Type<unknown> | null;
}
/**
 * Application-wide notification service. Use the convenience methods
 * (`success`, `error`, `warning`, `info`) to push a toast, or call
 * {@link show} for full control. A single `<ea-toast />` outlet must be
 * present in the app for toasts to appear.
 */
declare class ToastService {
    private nextId;
    private readonly timers;
    private paused;
    readonly toasts: _angular_core.WritableSignal<Toast[]>;
    /** Shows a toast and returns its id; pass `duration: 0` to disable auto-dismiss. */
    show(message: ToastText, options?: ToastOptions): number;
    /**
     * Suspends every auto-dismiss countdown, keeping the time each toast has
     * left. The `<ea-toast />` outlet calls this while the pointer or keyboard
     * focus is on the stack so users get time to read or reach the dismiss
     * button.
     */
    pause(): void;
    /** Resumes auto-dismiss countdowns suspended by {@link pause}. */
    resume(): void;
    /** Shows a `success` toast and returns its id. */
    success(message: ToastText, duration?: number): number;
    /** Shows an `error` toast and returns its id. */
    error(message: ToastText, duration?: number): number;
    /** Shows a `warning` toast and returns its id. */
    warning(message: ToastText, duration?: number): number;
    /** Shows an `info` toast and returns its id. */
    info(message: ToastText, duration?: number): number;
    /** Removes the toast with the given id, if it is still active. */
    dismiss(id: number): void;
    /** Removes all currently visible toasts. */
    clear(): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastService, never>;
    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
}

/** Corner or edge of the viewport the toast stack is pinned to. */
type ToastPosition = 'top-left' | 'top' | 'top-right' | 'bottom-left' | 'bottom' | 'bottom-right';
/** Visual size of every toast rendered by the outlet. */
type ToastSize = EaSize;
/**
 * Outlet that renders the stack of active toasts produced by
 * {@link ToastService}. Place a single `<ea-toast />` once in the root
 * template so toasts created from anywhere in the app are surfaced.
 */
declare class ToastComponent {
    protected readonly toastService: ToastService;
    protected readonly i18n: EagamiI18nService;
    private readonly containerEl;
    private hovered;
    private focused;
    /** Viewport corner or edge the toast stack is pinned to. */
    readonly position: _angular_core.InputSignal<ToastPosition>;
    /** Visual size applied to every toast in the stack. */
    readonly size: _angular_core.InputSignal<EaSize>;
    /** Show a dismiss button on each toast. */
    readonly clearable: _angular_core.InputSignal<boolean>;
    protected readonly containerClass: _angular_core.Signal<string>;
    protected toastRole(variant: string): 'alert' | 'status';
    protected segmentsOf(text: ToastText): readonly ToastSegment[] | null;
    protected segmentClass(segment: ToastSegment): string;
    protected onMouseEnter(): void;
    protected onMouseLeave(): void;
    protected onFocusIn(): void;
    protected onFocusOut(event: FocusEvent): void;
    private syncPause;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToastComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToastComponent, "ea-toast", never, { "position": { "alias": "position"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "clearable": { "alias": "clearable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * A single transferable item in an `<ea-transfer-list>`.
 *
 * `id` must be unique across the whole list. Items with `disabled: true` are
 * rendered greyed-out, cannot be highlighted, and are skipped by the
 * "move all" buttons (so disabled items stay where they are).
 */
interface TransferListItem {
    id: string;
    label: string;
    disabled?: boolean;
}

type TransferListSize = EaSize;
/**
 * `<ea-transfer-list>` is a two-pane shuttle control for moving items between
 * a "source" set and a "target" set. The full pool of items lives in
 * `[items]`; the `selectedIds` model tracks which subset is currently on the
 * target side. Highlighted-for-transfer state is internal to the component:
 * a user clicks one or more rows to highlight them, then clicks one of the
 * four direction buttons to move them.
 *
 * Each pane is a `role="listbox"` with `aria-multiselectable="true"`; rows
 * are `role="option"` with `aria-selected`.
 */
declare class TransferListComponent {
    private readonly i18n;
    readonly items: _angular_core.InputSignal<readonly TransferListItem[]>;
    /** Ids currently on the target (right) side. */
    readonly selectedIds: _angular_core.ModelSignal<readonly string[]>;
    /**
     * Heading rendered above the source (left) pane. Defaults to the localized
     * `transferList.sourceLabel` from i18n; pass an explicit empty string to
     * hide the heading row entirely.
     */
    readonly sourceLabel: _angular_core.InputSignal<string | undefined>;
    /**
     * Heading rendered above the target (right) pane. Defaults to the localized
     * `transferList.targetLabel` from i18n; pass an explicit empty string to
     * hide the heading row entirely.
     */
    readonly targetLabel: _angular_core.InputSignal<string | undefined>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    protected readonly messages: _angular_core.Signal<_eagami_ui.EagamiMessages>;
    private readonly leftHighlighted;
    private readonly rightHighlighted;
    private readonly leftAnchor;
    private readonly rightAnchor;
    private readonly leftActiveId;
    private readonly rightActiveId;
    private readonly leftActiveIndex;
    private readonly rightActiveIndex;
    protected readonly sourceItems: _angular_core.Signal<TransferListItem[]>;
    protected readonly targetItems: _angular_core.Signal<TransferListItem[]>;
    protected readonly canMoveRight: _angular_core.Signal<boolean>;
    protected readonly canMoveAllRight: _angular_core.Signal<boolean>;
    protected readonly canMoveLeft: _angular_core.Signal<boolean>;
    protected readonly canMoveAllLeft: _angular_core.Signal<boolean>;
    protected readonly resolvedSourceLabel: _angular_core.Signal<string>;
    protected readonly resolvedTargetLabel: _angular_core.Signal<string>;
    protected readonly announcement: _angular_core.WritableSignal<string>;
    protected readonly hostClasses: _angular_core.Signal<string[]>;
    protected isHighlighted(pane: 'source' | 'target', id: string): boolean;
    protected itemTabindex(pane: 'source' | 'target', index: number, item: TransferListItem): number;
    protected onItemClick(pane: 'source' | 'target', item: TransferListItem, event: MouseEvent): void;
    protected onItemKeydown(event: KeyboardEvent, pane: 'source' | 'target', item: TransferListItem): void;
    private resolveActiveIndex;
    private nextEnabledIndex;
    private setActive;
    private focusOption;
    private toggleHighlight;
    private selectRangeTo;
    protected moveSelectedRight(): void;
    protected moveAllRight(): void;
    protected moveSelectedLeft(): void;
    protected moveAllLeft(): void;
    private announceMove;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TransferListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TransferListComponent, "ea-transfer-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "selectedIds": { "alias": "selectedIds"; "required": false; "isSignal": true; }; "sourceLabel": { "alias": "sourceLabel"; "required": false; "isSignal": true; }; "targetLabel": { "alias": "targetLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, { "selectedIds": "selectedIdsChange"; }, never, never, true, never>;
}

/**
 * A single node in an `<ea-tree>` hierarchy.
 *
 * `id` must be unique across the entire tree (not just within siblings); it
 * drives selection state, expansion state, and keyboard focus.
 */
interface TreeNode<T = unknown> {
    /** Stable, unique identifier for the node. */
    id: string;
    /** Text label rendered for the node. */
    label: string;
    /** Child nodes. Omit (or empty array) to render as a leaf. */
    children?: readonly TreeNode<T>[];
    /** Optional leading-icon component class (e.g. `FolderIconComponent`). */
    icon?: Type<unknown>;
    /** When true, the node is skipped by keyboard navigation and cannot be selected. */
    disabled?: boolean;
    /** Arbitrary consumer-defined payload, passed through to `(nodeClick)`. */
    data?: T;
}
/**
 * Internal helper: walks a tree depth-first, yielding every node along with
 * its parent chain. Used by `<ea-tree>` for keyboard navigation and lookup.
 */
declare function walkTree<T>(nodes: readonly TreeNode<T>[], ancestors?: readonly TreeNode<T>[]): Generator<{
    node: TreeNode<T>;
    ancestors: readonly TreeNode<T>[];
}>;
/**
 * Returns the flat list of currently-visible node ids, in tab order. A node
 * is visible iff every ancestor up to the root is in `expandedIds`.
 */
declare function visibleNodeIds<T>(nodes: readonly TreeNode<T>[], expandedIds: ReadonlySet<string>): string[];

type TreeSize = EaSize;
/**
 * `<ea-tree>` renders a hierarchical, single-selection treeview with full
 * keyboard navigation (Arrow keys, Home, End, Enter / Space). Selection and
 * expansion state are model signals: pass `[selectedId]` / `[expandedIds]`
 * to control them, or bind `[(selectedId)]` / `[(expandedIds)]` for two-way
 * sync.
 *
 * The component implements the ARIA `tree` pattern:
 * - The outer `<ul>` carries `role="tree"`
 * - Each node is a `<li role="treeitem">` with `aria-level`, `aria-posinset`,
 *   `aria-setsize`, `aria-expanded` (branches only), and `aria-selected`
 * - Roving tabindex: only the currently-focused node has `tabindex="0"`
 */
declare class TreeComponent {
    private readonly hostEl;
    readonly nodes: _angular_core.InputSignal<readonly TreeNode<unknown>[]>;
    readonly size: _angular_core.InputSignal<EaSize>;
    readonly disabled: _angular_core.InputSignal<boolean>;
    /** Currently-selected node id. `null` means nothing is selected. */
    readonly selectedId: _angular_core.ModelSignal<string | null>;
    /** Ids of currently-expanded branch nodes. */
    readonly expandedIds: _angular_core.ModelSignal<readonly string[]>;
    /** Optional aria-label for the tree itself. */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    readonly nodeClick: _angular_core.OutputEmitterRef<TreeNode<unknown>>;
    private readonly listEl;
    private readonly _focusedId;
    protected readonly expandedSet: Signal<ReadonlySet<string>>;
    /**
     * The node id currently driving the roving tabindex. Defaults to the first
     * visible node if nothing has been focused yet, so Tab-into-tree lands on a
     * sensible target.
     */
    protected readonly focusedId: Signal<string>;
    protected readonly hostClasses: Signal<string[]>;
    constructor();
    protected onNodeSelect(node: TreeNode): void;
    protected onNodeToggle(id: string): void;
    protected onKeydown(event: KeyboardEvent): void;
    protected onTreeFocus(event: FocusEvent): void;
    private focusNode;
    private findNode;
    private findParentId;
    private findAncestorIds;
    private isNodeDisabled;
    protected readonly _listEl: Signal<ElementRef<HTMLElement> | undefined>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TreeComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TreeComponent, "ea-tree", never, { "nodes": { "alias": "nodes"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "selectedId": { "alias": "selectedId"; "required": false; "isSignal": true; }; "expandedIds": { "alias": "expandedIds"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "aria-label"; "required": false; "isSignal": true; }; }, { "selectedId": "selectedIdChange"; "expandedIds": "expandedIdsChange"; "nodeClick": "nodeClick"; }, never, never, true, never>;
}

/**
 * Context object passed to each `<ng-template #item>` projection inside an
 * `<ea-virtual-list>`. Mirrors `let-item="$implicit"` + `let-index="index"`.
 */
interface VirtualListItemContext<T = unknown> {
    $implicit: T;
    index: number;
}
/**
 * `<ea-virtual-list>` is a low-level windowed-rendering primitive: it only
 * mounts the items currently in the visible viewport (plus a small overscan)
 * so that lists of tens of thousands of rows scroll smoothly.
 *
 * Fixed-height items only. Variable-height virtualization would need either
 * a measurement pass per row or a height estimator, neither of which the
 * component implements.
 *
 * Usage:
 * ```html
 * <ea-virtual-list
 *   [items]="rows"
 *   [itemHeight]="40"
 *   [viewportHeight]="400">
 *   <ng-template #item let-row let-i="index">
 *     <div class="row">{{ i }}: {{ row.label }}</div>
 *   </ng-template>
 * </ea-virtual-list>
 * ```
 *
 * The component intentionally stays role-agnostic: the consumer wraps the
 * projected item with whatever ARIA the use case calls for (`role="listitem"`,
 * `role="option"`, `role="row"`, etc.) and applies `aria-setsize` /
 * `aria-posinset` using the projected `index` if needed.
 */
declare class VirtualListComponent {
    private readonly hostRole;
    protected readonly viewportTabindex: number | null;
    readonly items: _angular_core.InputSignal<readonly unknown[]>;
    /** Pixel height of each item. Must be > 0. */
    readonly itemHeight: _angular_core.InputSignal<number>;
    /** Pixel height of the scrolling viewport. Must be > 0. */
    readonly viewportHeight: _angular_core.InputSignal<number>;
    /**
     * Extra rows rendered above and below the visible window. A small buffer
     * (3-5) hides the edge of the window during fast scrolls; larger values
     * trade memory for smoothness.
     */
    readonly overscan: _angular_core.InputSignal<number>;
    /**
     * Accessible name for the scrollable viewport. When set, the viewport gets
     * `role="region"` with this label so keyboard and screen-reader users can
     * identify it. Leave unset when the consumer supplies its own ARIA
     * semantics around the list (e.g. an outer `role="listbox"`).
     */
    readonly ariaLabel: _angular_core.InputSignal<string | undefined>;
    /** Index of the first row currently visible at the top of the viewport. */
    readonly scrollIndexChange: _angular_core.OutputEmitterRef<number>;
    /** Template applied to each rendered item, projected via `<ng-template #item>`. */
    protected readonly itemTemplate: _angular_core.Signal<TemplateRef<VirtualListItemContext<unknown>>>;
    protected readonly viewportEl: _angular_core.Signal<ElementRef<HTMLElement> | undefined>;
    private readonly scrollTop;
    protected readonly totalHeight: _angular_core.Signal<number>;
    protected readonly viewportStyle: _angular_core.Signal<{
        height: string;
    }>;
    protected readonly spacerStyle: _angular_core.Signal<{
        height: string;
    }>;
    protected readonly visibleRange: _angular_core.Signal<{
        start: number;
        end: number;
    }>;
    protected readonly visibleItems: _angular_core.Signal<{
        index: number;
        item: unknown;
    }[]>;
    protected itemStyle(index: number): Record<string, string>;
    protected onScroll(event: Event): void;
    /**
     * Programmatically scroll the viewport so that the row at `index` is the
     * top-most visible row. Out-of-range values are clamped to the list bounds.
     */
    scrollToIndex(index: number): void;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VirtualListComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VirtualListComponent, "ea-virtual-list", never, { "items": { "alias": "items"; "required": true; "isSignal": true; }; "itemHeight": { "alias": "itemHeight"; "required": true; "isSignal": true; }; "viewportHeight": { "alias": "viewportHeight"; "required": true; "isSignal": true; }; "overscan": { "alias": "overscan"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; }, { "scrollIndexChange": "scrollIndexChange"; }, ["itemTemplate"], never, true, never>;
}

/**
 * Resolves an icon's human-readable display name. Pass the component class
 * (`iconDisplayName(GithubIconComponent)` returns `'GitHub'`) or its slug
 * (`iconDisplayName('github')` returns `'GitHub'`). Falls back to a generic
 * slug-to-Title-Case derivation when no override is defined.
 */
declare function iconDisplayName(iconOrSlug: IconComponentType | string): string;

/**
 * Flat list of every non-deprecated icon component shipped by Eagami UI,
 * sorted by `slug` so that consumers iterating it (the `/ui/icons` reference
 * page, the sandbox gallery, downstream pickers) get a stable alphabetical
 * order where a base icon always precedes its `-2` variant (e.g. `facebook`
 * before `facebook-2`). The literal below is kept in class-name order so a new
 * icon has one obvious insertion point; the `.sort()` at the bottom is the
 * source of truth for consumers.
 *
 * Bundle-size note: importing this constant brings every icon component into
 * the consuming bundle, which is the right trade-off when you actually want
 * the full set. For single-icon usage import the component directly (e.g.
 * `import { HomeIconComponent } from '@eagami/ui'`) and the bundler will
 * tree-shake `ICONS` away.
 */
declare const ICONS: ReadonlyArray<IconComponentType>;

declare class ActivityIconComponent extends IconComponentBase {
    static readonly slug = "activity";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ActivityIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ActivityIconComponent, "ea-icon-activity", never, {}, {}, never, never, true, never>;
}

declare class AirplayIconComponent extends IconComponentBase {
    static readonly slug = "airplay";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AirplayIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AirplayIconComponent, "ea-icon-airplay", never, {}, {}, never, never, true, never>;
}

declare class AlertCircleIconComponent extends IconComponentBase {
    static readonly slug = "alert-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertCircleIconComponent, "ea-icon-alert-circle", never, {}, {}, never, never, true, never>;
}

declare class AlertOctagonIconComponent extends IconComponentBase {
    static readonly slug = "alert-octagon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertOctagonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertOctagonIconComponent, "ea-icon-alert-octagon", never, {}, {}, never, never, true, never>;
}

declare class AlertTriangleIconComponent extends IconComponentBase {
    static readonly slug = "alert-triangle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlertTriangleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlertTriangleIconComponent, "ea-icon-alert-triangle", never, {}, {}, never, never, true, never>;
}

declare class AlignCenterIconComponent extends IconComponentBase {
    static readonly slug = "align-center";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlignCenterIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlignCenterIconComponent, "ea-icon-align-center", never, {}, {}, never, never, true, never>;
}

declare class AlignJustifyIconComponent extends IconComponentBase {
    static readonly slug = "align-justify";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlignJustifyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlignJustifyIconComponent, "ea-icon-align-justify", never, {}, {}, never, never, true, never>;
}

declare class AlignLeftIconComponent extends IconComponentBase {
    static readonly slug = "align-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlignLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlignLeftIconComponent, "ea-icon-align-left", never, {}, {}, never, never, true, never>;
}

declare class AlignRightIconComponent extends IconComponentBase {
    static readonly slug = "align-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AlignRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AlignRightIconComponent, "ea-icon-align-right", never, {}, {}, never, never, true, never>;
}

declare class AnchorIconComponent extends IconComponentBase {
    static readonly slug = "anchor";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnchorIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnchorIconComponent, "ea-icon-anchor", never, {}, {}, never, never, true, never>;
}

declare class AndroidIconComponent extends IconComponentBase {
    static readonly slug = "android";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AndroidIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AndroidIconComponent, "ea-icon-android", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AngularIconComponent extends IconComponentBase {
    static readonly slug = "angular";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AngularIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AngularIconComponent, "ea-icon-angular", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class AnthropicIconComponent extends IconComponentBase {
    static readonly slug = "anthropic";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnthropicIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnthropicIconComponent, "ea-icon-anthropic", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ApertureIconComponent extends IconComponentBase {
    static readonly slug = "aperture";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ApertureIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ApertureIconComponent, "ea-icon-aperture", never, {}, {}, never, never, true, never>;
}

declare class ArchiveIconComponent extends IconComponentBase {
    static readonly slug = "archive";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArchiveIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArchiveIconComponent, "ea-icon-archive", never, {}, {}, never, never, true, never>;
}

declare class ArrayIconComponent extends IconComponentBase {
    static readonly defaultStrokeWidth = 1.5;
    static readonly slug = "array";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrayIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayIconComponent, "ea-icon-array", never, {}, {}, never, never, true, never>;
}

declare class ArrowDownIconComponent extends IconComponentBase {
    static readonly slug = "arrow-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowDownIconComponent, "ea-icon-arrow-down", never, {}, {}, never, never, true, never>;
}

declare class ArrowDownCircleIconComponent extends IconComponentBase {
    static readonly slug = "arrow-down-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowDownCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowDownCircleIconComponent, "ea-icon-arrow-down-circle", never, {}, {}, never, never, true, never>;
}

declare class ArrowDownLeftIconComponent extends IconComponentBase {
    static readonly slug = "arrow-down-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowDownLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowDownLeftIconComponent, "ea-icon-arrow-down-left", never, {}, {}, never, never, true, never>;
}

declare class ArrowDownRightIconComponent extends IconComponentBase {
    static readonly slug = "arrow-down-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowDownRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowDownRightIconComponent, "ea-icon-arrow-down-right", never, {}, {}, never, never, true, never>;
}

declare class ArrowLeftIconComponent extends IconComponentBase {
    static readonly slug = "arrow-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowLeftIconComponent, "ea-icon-arrow-left", never, {}, {}, never, never, true, never>;
}

declare class ArrowLeftCircleIconComponent extends IconComponentBase {
    static readonly slug = "arrow-left-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowLeftCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowLeftCircleIconComponent, "ea-icon-arrow-left-circle", never, {}, {}, never, never, true, never>;
}

declare class ArrowRightIconComponent extends IconComponentBase {
    static readonly slug = "arrow-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowRightIconComponent, "ea-icon-arrow-right", never, {}, {}, never, never, true, never>;
}

declare class ArrowRightCircleIconComponent extends IconComponentBase {
    static readonly slug = "arrow-right-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowRightCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowRightCircleIconComponent, "ea-icon-arrow-right-circle", never, {}, {}, never, never, true, never>;
}

declare class ArrowUpIconComponent extends IconComponentBase {
    static readonly slug = "arrow-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowUpIconComponent, "ea-icon-arrow-up", never, {}, {}, never, never, true, never>;
}

declare class ArrowUpCircleIconComponent extends IconComponentBase {
    static readonly slug = "arrow-up-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowUpCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowUpCircleIconComponent, "ea-icon-arrow-up-circle", never, {}, {}, never, never, true, never>;
}

declare class ArrowUpLeftIconComponent extends IconComponentBase {
    static readonly slug = "arrow-up-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowUpLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowUpLeftIconComponent, "ea-icon-arrow-up-left", never, {}, {}, never, never, true, never>;
}

declare class ArrowUpRightIconComponent extends IconComponentBase {
    static readonly slug = "arrow-up-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrowUpRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrowUpRightIconComponent, "ea-icon-arrow-up-right", never, {}, {}, never, never, true, never>;
}

declare class AspectRatioIconComponent extends IconComponentBase {
    static readonly slug = "aspect-ratio";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AspectRatioIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AspectRatioIconComponent, "ea-icon-aspect-ratio", never, {}, {}, never, never, true, never>;
}

declare class AtSignIconComponent extends IconComponentBase {
    static readonly slug = "at-sign";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AtSignIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AtSignIconComponent, "ea-icon-at-sign", never, {}, {}, never, never, true, never>;
}

declare class AwardIconComponent extends IconComponentBase {
    static readonly slug = "award";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AwardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AwardIconComponent, "ea-icon-award", never, {}, {}, never, never, true, never>;
}

declare class BadgeCheckIconComponent extends IconComponentBase {
    static readonly slug = "badge-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BadgeCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BadgeCheckIconComponent, "ea-icon-badge-check", never, {}, {}, never, never, true, never>;
}

declare class BarChartIconComponent extends IconComponentBase {
    static readonly slug = "bar-chart";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BarChartIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BarChartIconComponent, "ea-icon-bar-chart", never, {}, {}, never, never, true, never>;
}

declare class BarChart2IconComponent extends IconComponentBase {
    static readonly slug = "bar-chart-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BarChart2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BarChart2IconComponent, "ea-icon-bar-chart-2", never, {}, {}, never, never, true, never>;
}

declare class BatteryIconComponent extends IconComponentBase {
    static readonly slug = "battery";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatteryIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BatteryIconComponent, "ea-icon-battery", never, {}, {}, never, never, true, never>;
}

declare class BatteryChargingIconComponent extends IconComponentBase {
    static readonly slug = "battery-charging";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatteryChargingIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BatteryChargingIconComponent, "ea-icon-battery-charging", never, {}, {}, never, never, true, never>;
}

declare class BellIconComponent extends IconComponentBase {
    static readonly slug = "bell";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BellIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BellIconComponent, "ea-icon-bell", never, {}, {}, never, never, true, never>;
}

declare class BellOffIconComponent extends IconComponentBase {
    static readonly slug = "bell-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BellOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BellOffIconComponent, "ea-icon-bell-off", never, {}, {}, never, never, true, never>;
}

declare class BellRingIconComponent extends IconComponentBase {
    static readonly slug = "bell-ring";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BellRingIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BellRingIconComponent, "ea-icon-bell-ring", never, {}, {}, never, never, true, never>;
}

declare class BitcoinIconComponent extends IconComponentBase {
    static readonly slug = "bitcoin";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BitcoinIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BitcoinIconComponent, "ea-icon-bitcoin", never, {}, {}, never, never, true, never>;
}

declare class BlueskyIconComponent extends IconComponentBase {
    static readonly slug = "bluesky";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BlueskyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BlueskyIconComponent, "ea-icon-bluesky", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class BluetoothIconComponent extends IconComponentBase {
    static readonly slug = "bluetooth";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BluetoothIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BluetoothIconComponent, "ea-icon-bluetooth", never, {}, {}, never, never, true, never>;
}

declare class BoldIconComponent extends IconComponentBase {
    static readonly slug = "bold";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BoldIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BoldIconComponent, "ea-icon-bold", never, {}, {}, never, never, true, never>;
}

declare class BookIconComponent extends IconComponentBase {
    static readonly slug = "book";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BookIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BookIconComponent, "ea-icon-book", never, {}, {}, never, never, true, never>;
}

declare class BookOpenIconComponent extends IconComponentBase {
    static readonly slug = "book-open";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BookOpenIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BookOpenIconComponent, "ea-icon-book-open", never, {}, {}, never, never, true, never>;
}

declare class BookmarkIconComponent extends IconComponentBase {
    static readonly slug = "bookmark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BookmarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BookmarkIconComponent, "ea-icon-bookmark", never, {}, {}, never, never, true, never>;
}

declare class BookmarkCheckIconComponent extends IconComponentBase {
    static readonly slug = "bookmark-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BookmarkCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BookmarkCheckIconComponent, "ea-icon-bookmark-check", never, {}, {}, never, never, true, never>;
}

declare class BookmarkPlusIconComponent extends IconComponentBase {
    static readonly slug = "bookmark-plus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BookmarkPlusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BookmarkPlusIconComponent, "ea-icon-bookmark-plus", never, {}, {}, never, never, true, never>;
}

declare class BotIconComponent extends IconComponentBase {
    static readonly slug = "bot";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BotIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BotIconComponent, "ea-icon-bot", never, {}, {}, never, never, true, never>;
}

declare class BottleIconComponent extends IconComponentBase {
    static readonly slug = "bottle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BottleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BottleIconComponent, "ea-icon-bottle", never, {}, {}, never, never, true, never>;
}

declare class BoxIconComponent extends IconComponentBase {
    static readonly slug = "box";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BoxIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BoxIconComponent, "ea-icon-box", never, {}, {}, never, never, true, never>;
}

declare class BrainIconComponent extends IconComponentBase {
    static readonly slug = "brain";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BrainIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BrainIconComponent, "ea-icon-brain", never, {}, {}, never, never, true, never>;
}

declare class BriefcaseIconComponent extends IconComponentBase {
    static readonly slug = "briefcase";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BriefcaseIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BriefcaseIconComponent, "ea-icon-briefcase", never, {}, {}, never, never, true, never>;
}

declare class BugIconComponent extends IconComponentBase {
    static readonly slug = "bug";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BugIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BugIconComponent, "ea-icon-bug", never, {}, {}, never, never, true, never>;
}

declare class BuildingIconComponent extends IconComponentBase {
    static readonly slug = "building";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BuildingIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BuildingIconComponent, "ea-icon-building", never, {}, {}, never, never, true, never>;
}

declare class CalculatorIconComponent extends IconComponentBase {
    static readonly slug = "calculator";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalculatorIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalculatorIconComponent, "ea-icon-calculator", never, {}, {}, never, never, true, never>;
}

declare class CalendarIconComponent extends IconComponentBase {
    static readonly slug = "calendar";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarIconComponent, "ea-icon-calendar", never, {}, {}, never, never, true, never>;
}

declare class CalendarCheckIconComponent extends IconComponentBase {
    static readonly slug = "calendar-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarCheckIconComponent, "ea-icon-calendar-check", never, {}, {}, never, never, true, never>;
}

declare class CalendarDaysIconComponent extends IconComponentBase {
    static readonly slug = "calendar-days";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CalendarDaysIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CalendarDaysIconComponent, "ea-icon-calendar-days", never, {}, {}, never, never, true, never>;
}

declare class CameraIconComponent extends IconComponentBase {
    static readonly slug = "camera";
    static readonly category: IconCategory;
    static readonly defaultStrokeWidth = 1.5;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CameraIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CameraIconComponent, "ea-icon-camera", never, {}, {}, never, never, true, never>;
}

declare class CameraOffIconComponent extends IconComponentBase {
    static readonly slug = "camera-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CameraOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CameraOffIconComponent, "ea-icon-camera-off", never, {}, {}, never, never, true, never>;
}

declare class CandleIconComponent extends IconComponentBase {
    static readonly slug = "candle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CandleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CandleIconComponent, "ea-icon-candle", never, {}, {}, never, never, true, never>;
}

declare class CastIconComponent extends IconComponentBase {
    static readonly slug = "cast";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CastIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CastIconComponent, "ea-icon-cast", never, {}, {}, never, never, true, never>;
}

declare class CheckIconComponent extends IconComponentBase {
    static readonly slug = "check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckIconComponent, "ea-icon-check", never, {}, {}, never, never, true, never>;
}

declare class CheckCircleIconComponent extends IconComponentBase {
    static readonly slug = "check-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckCircleIconComponent, "ea-icon-check-circle", never, {}, {}, never, never, true, never>;
}

declare class CheckSquareIconComponent extends IconComponentBase {
    static readonly slug = "check-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CheckSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CheckSquareIconComponent, "ea-icon-check-square", never, {}, {}, never, never, true, never>;
}

declare class ChevronDownIconComponent extends IconComponentBase {
    static readonly slug = "chevron-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronDownIconComponent, "ea-icon-chevron-down", never, {}, {}, never, never, true, never>;
}

declare class ChevronLeftIconComponent extends IconComponentBase {
    static readonly slug = "chevron-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronLeftIconComponent, "ea-icon-chevron-left", never, {}, {}, never, never, true, never>;
}

declare class ChevronRightIconComponent extends IconComponentBase {
    static readonly slug = "chevron-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronRightIconComponent, "ea-icon-chevron-right", never, {}, {}, never, never, true, never>;
}

declare class ChevronUpIconComponent extends IconComponentBase {
    static readonly slug = "chevron-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronUpIconComponent, "ea-icon-chevron-up", never, {}, {}, never, never, true, never>;
}

declare class ChevronsDownIconComponent extends IconComponentBase {
    static readonly slug = "chevrons-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronsDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronsDownIconComponent, "ea-icon-chevrons-down", never, {}, {}, never, never, true, never>;
}

declare class ChevronsLeftIconComponent extends IconComponentBase {
    static readonly slug = "chevrons-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronsLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronsLeftIconComponent, "ea-icon-chevrons-left", never, {}, {}, never, never, true, never>;
}

declare class ChevronsRightIconComponent extends IconComponentBase {
    static readonly slug = "chevrons-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronsRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronsRightIconComponent, "ea-icon-chevrons-right", never, {}, {}, never, never, true, never>;
}

declare class ChevronsUpIconComponent extends IconComponentBase {
    static readonly slug = "chevrons-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronsUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronsUpIconComponent, "ea-icon-chevrons-up", never, {}, {}, never, never, true, never>;
}

declare class ChevronsUpDownIconComponent extends IconComponentBase {
    static readonly slug = "chevrons-up-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChevronsUpDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChevronsUpDownIconComponent, "ea-icon-chevrons-up-down", never, {}, {}, never, never, true, never>;
}

declare class ChromeIconComponent extends IconComponentBase {
    static readonly slug = "chrome";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChromeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChromeIconComponent, "ea-icon-chrome", never, {}, {}, never, never, true, never>;
}

declare class CircleIconComponent extends IconComponentBase {
    static readonly slug = "circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CircleIconComponent, "ea-icon-circle", never, {}, {}, never, never, true, never>;
}

declare class ClapperboardIconComponent extends IconComponentBase {
    static readonly slug = "clapperboard";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClapperboardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClapperboardIconComponent, "ea-icon-clapperboard", never, {}, {}, never, never, true, never>;
}

declare class ClipboardIconComponent extends IconComponentBase {
    static readonly slug = "clipboard";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipboardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClipboardIconComponent, "ea-icon-clipboard", never, {}, {}, never, never, true, never>;
}

declare class ClipboardCheckIconComponent extends IconComponentBase {
    static readonly slug = "clipboard-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipboardCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClipboardCheckIconComponent, "ea-icon-clipboard-check", never, {}, {}, never, never, true, never>;
}

declare class ClipboardListIconComponent extends IconComponentBase {
    static readonly slug = "clipboard-list";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClipboardListIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClipboardListIconComponent, "ea-icon-clipboard-list", never, {}, {}, never, never, true, never>;
}

declare class ClockIconComponent extends IconComponentBase {
    static readonly slug = "clock";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ClockIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ClockIconComponent, "ea-icon-clock", never, {}, {}, never, never, true, never>;
}

declare class CloudIconComponent extends IconComponentBase {
    static readonly slug = "cloud";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudIconComponent, "ea-icon-cloud", never, {}, {}, never, never, true, never>;
}

declare class CloudDrizzleIconComponent extends IconComponentBase {
    static readonly slug = "cloud-drizzle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudDrizzleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudDrizzleIconComponent, "ea-icon-cloud-drizzle", never, {}, {}, never, never, true, never>;
}

declare class CloudLightningIconComponent extends IconComponentBase {
    static readonly slug = "cloud-lightning";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudLightningIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudLightningIconComponent, "ea-icon-cloud-lightning", never, {}, {}, never, never, true, never>;
}

declare class CloudOffIconComponent extends IconComponentBase {
    static readonly slug = "cloud-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudOffIconComponent, "ea-icon-cloud-off", never, {}, {}, never, never, true, never>;
}

declare class CloudRainIconComponent extends IconComponentBase {
    static readonly slug = "cloud-rain";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudRainIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudRainIconComponent, "ea-icon-cloud-rain", never, {}, {}, never, never, true, never>;
}

declare class CloudSnowIconComponent extends IconComponentBase {
    static readonly slug = "cloud-snow";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudSnowIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudSnowIconComponent, "ea-icon-cloud-snow", never, {}, {}, never, never, true, never>;
}

declare class CloudflareIconComponent extends IconComponentBase {
    static readonly slug = "cloudflare";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CloudflareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CloudflareIconComponent, "ea-icon-cloudflare", never, {}, {}, never, never, true, never>;
}

declare class CodeIconComponent extends IconComponentBase {
    static readonly slug = "code";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodeIconComponent, "ea-icon-code", never, {}, {}, never, never, true, never>;
}

declare class CodepenIconComponent extends IconComponentBase {
    static readonly slug = "codepen";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodepenIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodepenIconComponent, "ea-icon-codepen", never, {}, {}, never, never, true, never>;
}

declare class CodesandboxIconComponent extends IconComponentBase {
    static readonly slug = "codesandbox";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CodesandboxIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CodesandboxIconComponent, "ea-icon-codesandbox", never, {}, {}, never, never, true, never>;
}

declare class CoffeeIconComponent extends IconComponentBase {
    static readonly slug = "coffee";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoffeeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoffeeIconComponent, "ea-icon-coffee", never, {}, {}, never, never, true, never>;
}

declare class CoinsIconComponent extends IconComponentBase {
    static readonly slug = "coins";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CoinsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CoinsIconComponent, "ea-icon-coins", never, {}, {}, never, never, true, never>;
}

declare class ColumnsIconComponent extends IconComponentBase {
    static readonly slug = "columns";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ColumnsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ColumnsIconComponent, "ea-icon-columns", never, {}, {}, never, never, true, never>;
}

declare class CommandIconComponent extends IconComponentBase {
    static readonly slug = "command";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CommandIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CommandIconComponent, "ea-icon-command", never, {}, {}, never, never, true, never>;
}

declare class CompassIconComponent extends IconComponentBase {
    static readonly slug = "compass";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CompassIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CompassIconComponent, "ea-icon-compass", never, {}, {}, never, never, true, never>;
}

declare class ContrastIconComponent extends IconComponentBase {
    static readonly slug = "contrast";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContrastIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ContrastIconComponent, "ea-icon-contrast", never, {}, {}, never, never, true, never>;
}

declare class CopyIconComponent extends IconComponentBase {
    static readonly slug = "copy";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CopyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CopyIconComponent, "ea-icon-copy", never, {}, {}, never, never, true, never>;
}

declare class CornerDownLeftIconComponent extends IconComponentBase {
    static readonly slug = "corner-down-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerDownLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerDownLeftIconComponent, "ea-icon-corner-down-left", never, {}, {}, never, never, true, never>;
}

declare class CornerDownRightIconComponent extends IconComponentBase {
    static readonly slug = "corner-down-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerDownRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerDownRightIconComponent, "ea-icon-corner-down-right", never, {}, {}, never, never, true, never>;
}

declare class CornerLeftDownIconComponent extends IconComponentBase {
    static readonly slug = "corner-left-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerLeftDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerLeftDownIconComponent, "ea-icon-corner-left-down", never, {}, {}, never, never, true, never>;
}

declare class CornerLeftUpIconComponent extends IconComponentBase {
    static readonly slug = "corner-left-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerLeftUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerLeftUpIconComponent, "ea-icon-corner-left-up", never, {}, {}, never, never, true, never>;
}

declare class CornerRightDownIconComponent extends IconComponentBase {
    static readonly slug = "corner-right-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerRightDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerRightDownIconComponent, "ea-icon-corner-right-down", never, {}, {}, never, never, true, never>;
}

declare class CornerRightUpIconComponent extends IconComponentBase {
    static readonly slug = "corner-right-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerRightUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerRightUpIconComponent, "ea-icon-corner-right-up", never, {}, {}, never, never, true, never>;
}

declare class CornerUpLeftIconComponent extends IconComponentBase {
    static readonly slug = "corner-up-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerUpLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerUpLeftIconComponent, "ea-icon-corner-up-left", never, {}, {}, never, never, true, never>;
}

declare class CornerUpRightIconComponent extends IconComponentBase {
    static readonly slug = "corner-up-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CornerUpRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CornerUpRightIconComponent, "ea-icon-corner-up-right", never, {}, {}, never, never, true, never>;
}

declare class CpuIconComponent extends IconComponentBase {
    static readonly slug = "cpu";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CpuIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CpuIconComponent, "ea-icon-cpu", never, {}, {}, never, never, true, never>;
}

declare class CreditCardIconComponent extends IconComponentBase {
    static readonly slug = "credit-card";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CreditCardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CreditCardIconComponent, "ea-icon-credit-card", never, {}, {}, never, never, true, never>;
}

declare class CropIconComponent extends IconComponentBase {
    static readonly slug = "crop";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CropIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CropIconComponent, "ea-icon-crop", never, {}, {}, never, never, true, never>;
}

declare class CrosshairIconComponent extends IconComponentBase {
    static readonly slug = "crosshair";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<CrosshairIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<CrosshairIconComponent, "ea-icon-crosshair", never, {}, {}, never, never, true, never>;
}

declare class DatabaseIconComponent extends IconComponentBase {
    static readonly slug = "database";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DatabaseIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DatabaseIconComponent, "ea-icon-database", never, {}, {}, never, never, true, never>;
}

declare class DeleteIconComponent extends IconComponentBase {
    static readonly slug = "delete";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DeleteIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DeleteIconComponent, "ea-icon-delete", never, {}, {}, never, never, true, never>;
}

declare class Dice1IconComponent extends IconComponentBase {
    static readonly slug = "dice-1";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dice1IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dice1IconComponent, "ea-icon-dice-1", never, {}, {}, never, never, true, never>;
}

declare class Dice2IconComponent extends IconComponentBase {
    static readonly slug = "dice-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dice2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dice2IconComponent, "ea-icon-dice-2", never, {}, {}, never, never, true, never>;
}

declare class Dice3IconComponent extends IconComponentBase {
    static readonly slug = "dice-3";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dice3IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dice3IconComponent, "ea-icon-dice-3", never, {}, {}, never, never, true, never>;
}

declare class Dice4IconComponent extends IconComponentBase {
    static readonly slug = "dice-4";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dice4IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dice4IconComponent, "ea-icon-dice-4", never, {}, {}, never, never, true, never>;
}

declare class Dice5IconComponent extends IconComponentBase {
    static readonly slug = "dice-5";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dice5IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dice5IconComponent, "ea-icon-dice-5", never, {}, {}, never, never, true, never>;
}

declare class Dice6IconComponent extends IconComponentBase {
    static readonly slug = "dice-6";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Dice6IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Dice6IconComponent, "ea-icon-dice-6", never, {}, {}, never, never, true, never>;
}

declare class DiscIconComponent extends IconComponentBase {
    static readonly slug = "disc";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DiscIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DiscIconComponent, "ea-icon-disc", never, {}, {}, never, never, true, never>;
}

declare class DiscordIconComponent extends IconComponentBase {
    static readonly slug = "discord";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DiscordIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DiscordIconComponent, "ea-icon-discord", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DivideIconComponent extends IconComponentBase {
    static readonly slug = "divide";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DivideIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DivideIconComponent, "ea-icon-divide", never, {}, {}, never, never, true, never>;
}

declare class DivideCircleIconComponent extends IconComponentBase {
    static readonly slug = "divide-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DivideCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DivideCircleIconComponent, "ea-icon-divide-circle", never, {}, {}, never, never, true, never>;
}

declare class DivideSquareIconComponent extends IconComponentBase {
    static readonly slug = "divide-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DivideSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DivideSquareIconComponent, "ea-icon-divide-square", never, {}, {}, never, never, true, never>;
}

declare class DockerIconComponent extends IconComponentBase {
    static readonly slug = "docker";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DockerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DockerIconComponent, "ea-icon-docker", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DollarSignIconComponent extends IconComponentBase {
    static readonly slug = "dollar-sign";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DollarSignIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DollarSignIconComponent, "ea-icon-dollar-sign", never, {}, {}, never, never, true, never>;
}

declare class DoubleExclamationMarkIconComponent extends IconComponentBase {
    static readonly slug = "double-exclamation-mark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DoubleExclamationMarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DoubleExclamationMarkIconComponent, "ea-icon-double-exclamation-mark", never, {}, {}, never, never, true, never>;
}

declare class DoubleQuestionMarkIconComponent extends IconComponentBase {
    static readonly slug = "double-question-mark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DoubleQuestionMarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DoubleQuestionMarkIconComponent, "ea-icon-double-question-mark", never, {}, {}, never, never, true, never>;
}

declare class DownloadIconComponent extends IconComponentBase {
    static readonly slug = "download";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DownloadIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DownloadIconComponent, "ea-icon-download", never, {}, {}, never, never, true, never>;
}

declare class DownloadCloudIconComponent extends IconComponentBase {
    static readonly slug = "download-cloud";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DownloadCloudIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DownloadCloudIconComponent, "ea-icon-download-cloud", never, {}, {}, never, never, true, never>;
}

declare class DribbbleIconComponent extends IconComponentBase {
    static readonly slug = "dribbble";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DribbbleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DribbbleIconComponent, "ea-icon-dribbble", never, {}, {}, never, never, true, never>;
}

declare class DropboxIconComponent extends IconComponentBase {
    static readonly slug = "dropbox";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropboxIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropboxIconComponent, "ea-icon-dropbox", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class DropletIconComponent extends IconComponentBase {
    static readonly slug = "droplet";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DropletIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DropletIconComponent, "ea-icon-droplet", never, {}, {}, never, never, true, never>;
}

declare class EagamiIconComponent extends IconComponentBase {
    static readonly slug = "eagami";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EagamiIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EagamiIconComponent, "ea-icon-eagami", never, {}, {}, never, never, true, never>;
}

declare class EditIconComponent extends IconComponentBase {
    static readonly slug = "edit";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EditIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EditIconComponent, "ea-icon-edit", never, {}, {}, never, never, true, never>;
}

declare class Edit2IconComponent extends IconComponentBase {
    static readonly slug = "edit-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Edit2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Edit2IconComponent, "ea-icon-edit-2", never, {}, {}, never, never, true, never>;
}

declare class Edit3IconComponent extends IconComponentBase {
    static readonly slug = "edit-3";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Edit3IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Edit3IconComponent, "ea-icon-edit-3", never, {}, {}, never, never, true, never>;
}

declare class ExclamationMarkIconComponent extends IconComponentBase {
    static readonly slug = "exclamation-mark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExclamationMarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExclamationMarkIconComponent, "ea-icon-exclamation-mark", never, {}, {}, never, never, true, never>;
}

declare class ExclamationQuestionMarkIconComponent extends IconComponentBase {
    static readonly slug = "exclamation-question-mark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExclamationQuestionMarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExclamationQuestionMarkIconComponent, "ea-icon-exclamation-question-mark", never, {}, {}, never, never, true, never>;
}

declare class ExternalLinkIconComponent extends IconComponentBase {
    static readonly slug = "external-link";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ExternalLinkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ExternalLinkIconComponent, "ea-icon-external-link", never, {}, {}, never, never, true, never>;
}

declare class EyeIconComponent extends IconComponentBase {
    static readonly slug = "eye";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EyeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EyeIconComponent, "ea-icon-eye", never, {}, {}, never, never, true, never>;
}

declare class EyeOffIconComponent extends IconComponentBase {
    static readonly slug = "eye-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<EyeOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<EyeOffIconComponent, "ea-icon-eye-off", never, {}, {}, never, never, true, never>;
}

/**
 * Facebook icon (Feather outline).
 *
 * @remarks
 * The brand-filled Facebook mark lives at `<ea-icon-facebook-2>` /
 * `Facebook2IconComponent`.
 */
declare class FacebookIconComponent extends IconComponentBase {
    static readonly slug = "facebook";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FacebookIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FacebookIconComponent, "ea-icon-facebook", never, {}, {}, never, never, true, never>;
}

/**
 * Facebook brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-facebook>` / `FacebookIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Facebook2IconComponent extends IconComponentBase {
    static readonly slug = "facebook-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Facebook2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Facebook2IconComponent, "ea-icon-facebook-2", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class FastForwardIconComponent extends IconComponentBase {
    static readonly slug = "fast-forward";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FastForwardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FastForwardIconComponent, "ea-icon-fast-forward", never, {}, {}, never, never, true, never>;
}

declare class FeatherIconComponent extends IconComponentBase {
    static readonly slug = "feather";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeatherIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FeatherIconComponent, "ea-icon-feather", never, {}, {}, never, never, true, never>;
}

/**
 * Figma icon (Feather outline).
 *
 * @remarks
 * The brand-filled Figma mark lives at `<ea-icon-figma-2>` /
 * `Figma2IconComponent`.
 */
declare class FigmaIconComponent extends IconComponentBase {
    static readonly slug = "figma";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FigmaIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FigmaIconComponent, "ea-icon-figma", never, {}, {}, never, never, true, never>;
}

/**
 * Figma brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-figma>` / `FigmaIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Figma2IconComponent extends IconComponentBase {
    static readonly slug = "figma-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Figma2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Figma2IconComponent, "ea-icon-figma-2", never, {}, {}, never, never, true, never>;
}

declare class FileIconComponent extends IconComponentBase {
    static readonly slug = "file";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileIconComponent, "ea-icon-file", never, {}, {}, never, never, true, never>;
}

declare class FileAudioIconComponent extends IconComponentBase {
    static readonly slug = "file-audio";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileAudioIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileAudioIconComponent, "ea-icon-file-audio", never, {}, {}, never, never, true, never>;
}

declare class FileCheckIconComponent extends IconComponentBase {
    static readonly slug = "file-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileCheckIconComponent, "ea-icon-file-check", never, {}, {}, never, never, true, never>;
}

declare class FileImageIconComponent extends IconComponentBase {
    static readonly slug = "file-image";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileImageIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileImageIconComponent, "ea-icon-file-image", never, {}, {}, never, never, true, never>;
}

declare class FileMinusIconComponent extends IconComponentBase {
    static readonly slug = "file-minus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileMinusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileMinusIconComponent, "ea-icon-file-minus", never, {}, {}, never, never, true, never>;
}

declare class FilePdfIconComponent extends IconComponentBase {
    static readonly slug = "file-pdf";
    static readonly category: IconCategory;
    static readonly defaultStrokeWidth = 1.5;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilePdfIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilePdfIconComponent, "ea-icon-file-pdf", never, {}, {}, never, never, true, never>;
}

declare class FilePlusIconComponent extends IconComponentBase {
    static readonly slug = "file-plus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilePlusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilePlusIconComponent, "ea-icon-file-plus", never, {}, {}, never, never, true, never>;
}

declare class FileTextIconComponent extends IconComponentBase {
    static readonly slug = "file-text";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileTextIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileTextIconComponent, "ea-icon-file-text", never, {}, {}, never, never, true, never>;
}

declare class FileVideoIconComponent extends IconComponentBase {
    static readonly slug = "file-video";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FileVideoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FileVideoIconComponent, "ea-icon-file-video", never, {}, {}, never, never, true, never>;
}

declare class FilmIconComponent extends IconComponentBase {
    static readonly slug = "film";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilmIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilmIconComponent, "ea-icon-film", never, {}, {}, never, never, true, never>;
}

declare class FilterIconComponent extends IconComponentBase {
    static readonly slug = "filter";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterIconComponent, "ea-icon-filter", never, {}, {}, never, never, true, never>;
}

declare class FilterXIconComponent extends IconComponentBase {
    static readonly slug = "filter-x";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FilterXIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FilterXIconComponent, "ea-icon-filter-x", never, {}, {}, never, never, true, never>;
}

declare class FingerprintIconComponent extends IconComponentBase {
    static readonly slug = "fingerprint";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FingerprintIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FingerprintIconComponent, "ea-icon-fingerprint", never, {}, {}, never, never, true, never>;
}

declare class FirstPlaceMedalIconComponent extends IconComponentBase {
    static readonly slug = "first-place-medal";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FirstPlaceMedalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FirstPlaceMedalIconComponent, "ea-icon-first-place-medal", never, {}, {}, never, never, true, never>;
}

declare class FlagIconComponent extends IconComponentBase {
    static readonly slug = "flag";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlagIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlagIconComponent, "ea-icon-flag", never, {}, {}, never, never, true, never>;
}

declare class FlameIconComponent extends IconComponentBase {
    static readonly slug = "flame";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FlameIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FlameIconComponent, "ea-icon-flame", never, {}, {}, never, never, true, never>;
}

declare class FolderIconComponent extends IconComponentBase {
    static readonly slug = "folder";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FolderIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FolderIconComponent, "ea-icon-folder", never, {}, {}, never, never, true, never>;
}

declare class FolderMinusIconComponent extends IconComponentBase {
    static readonly slug = "folder-minus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FolderMinusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FolderMinusIconComponent, "ea-icon-folder-minus", never, {}, {}, never, never, true, never>;
}

declare class FolderOpenIconComponent extends IconComponentBase {
    static readonly slug = "folder-open";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FolderOpenIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FolderOpenIconComponent, "ea-icon-folder-open", never, {}, {}, never, never, true, never>;
}

declare class FolderPlusIconComponent extends IconComponentBase {
    static readonly slug = "folder-plus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FolderPlusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FolderPlusIconComponent, "ea-icon-folder-plus", never, {}, {}, never, never, true, never>;
}

declare class FramerIconComponent extends IconComponentBase {
    static readonly slug = "framer";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FramerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FramerIconComponent, "ea-icon-framer", never, {}, {}, never, never, true, never>;
}

declare class FrownIconComponent extends IconComponentBase {
    static readonly slug = "frown";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FrownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FrownIconComponent, "ea-icon-frown", never, {}, {}, never, never, true, never>;
}

declare class GaugeIconComponent extends IconComponentBase {
    static readonly slug = "gauge";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GaugeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GaugeIconComponent, "ea-icon-gauge", never, {}, {}, never, never, true, never>;
}

declare class GeminiIconComponent extends IconComponentBase {
    static readonly slug = "gemini";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GeminiIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GeminiIconComponent, "ea-icon-gemini", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GiftIconComponent extends IconComponentBase {
    static readonly slug = "gift";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GiftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GiftIconComponent, "ea-icon-gift", never, {}, {}, never, never, true, never>;
}

declare class GitBranchIconComponent extends IconComponentBase {
    static readonly slug = "git-branch";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GitBranchIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GitBranchIconComponent, "ea-icon-git-branch", never, {}, {}, never, never, true, never>;
}

declare class GitCommitIconComponent extends IconComponentBase {
    static readonly slug = "git-commit";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GitCommitIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GitCommitIconComponent, "ea-icon-git-commit", never, {}, {}, never, never, true, never>;
}

declare class GitCompareIconComponent extends IconComponentBase {
    static readonly slug = "git-compare";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GitCompareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GitCompareIconComponent, "ea-icon-git-compare", never, {}, {}, never, never, true, never>;
}

declare class GitMergeIconComponent extends IconComponentBase {
    static readonly slug = "git-merge";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GitMergeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GitMergeIconComponent, "ea-icon-git-merge", never, {}, {}, never, never, true, never>;
}

declare class GitPullRequestIconComponent extends IconComponentBase {
    static readonly slug = "git-pull-request";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GitPullRequestIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GitPullRequestIconComponent, "ea-icon-git-pull-request", never, {}, {}, never, never, true, never>;
}

/**
 * GitHub icon (Feather outline).
 *
 * @remarks
 * The brand-filled GitHub mark lives at `<ea-icon-github-2>` /
 * `Github2IconComponent`.
 */
declare class GithubIconComponent extends IconComponentBase {
    static readonly slug = "github";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GithubIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GithubIconComponent, "ea-icon-github", never, {}, {}, never, never, true, never>;
}

/**
 * GitHub brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-github>` / `GithubIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Github2IconComponent extends IconComponentBase {
    static readonly slug = "github-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Github2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Github2IconComponent, "ea-icon-github-2", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GitlabIconComponent extends IconComponentBase {
    static readonly slug = "gitlab";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GitlabIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GitlabIconComponent, "ea-icon-gitlab", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class GlobeIconComponent extends IconComponentBase {
    static readonly slug = "globe";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GlobeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GlobeIconComponent, "ea-icon-globe", never, {}, {}, never, never, true, never>;
}

declare class GoogleIconComponent extends IconComponentBase {
    static readonly slug = "google";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GoogleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GoogleIconComponent, "ea-icon-google", never, {}, {}, never, never, true, never>;
}

declare class GridIconComponent extends IconComponentBase {
    static readonly slug = "grid";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GridIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<GridIconComponent, "ea-icon-grid", never, {}, {}, never, never, true, never>;
}

declare class HalfCircleIconComponent extends IconComponentBase {
    static readonly slug = "half-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HalfCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HalfCircleIconComponent, "ea-icon-half-circle", never, {}, {}, never, never, true, never>;
}

declare class HalfHeartIconComponent extends IconComponentBase {
    static readonly slug = "half-heart";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HalfHeartIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HalfHeartIconComponent, "ea-icon-half-heart", never, {}, {}, never, never, true, never>;
}

declare class HardDriveIconComponent extends IconComponentBase {
    static readonly slug = "hard-drive";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HardDriveIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HardDriveIconComponent, "ea-icon-hard-drive", never, {}, {}, never, never, true, never>;
}

declare class HashIconComponent extends IconComponentBase {
    static readonly slug = "hash";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HashIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HashIconComponent, "ea-icon-hash", never, {}, {}, never, never, true, never>;
}

declare class HeadphonesIconComponent extends IconComponentBase {
    static readonly slug = "headphones";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeadphonesIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeadphonesIconComponent, "ea-icon-headphones", never, {}, {}, never, never, true, never>;
}

declare class HeartIconComponent extends IconComponentBase {
    static readonly slug = "heart";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeartIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeartIconComponent, "ea-icon-heart", never, {}, {}, never, never, true, never>;
}

declare class HelpCircleIconComponent extends IconComponentBase {
    static readonly slug = "help-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HelpCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HelpCircleIconComponent, "ea-icon-help-circle", never, {}, {}, never, never, true, never>;
}

declare class HeptagonIconComponent extends IconComponentBase {
    static readonly slug = "heptagon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HeptagonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HeptagonIconComponent, "ea-icon-heptagon", never, {}, {}, never, never, true, never>;
}

declare class HexagonIconComponent extends IconComponentBase {
    static readonly slug = "hexagon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HexagonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HexagonIconComponent, "ea-icon-hexagon", never, {}, {}, never, never, true, never>;
}

declare class HistoryIconComponent extends IconComponentBase {
    static readonly slug = "history";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HistoryIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HistoryIconComponent, "ea-icon-history", never, {}, {}, never, never, true, never>;
}

declare class HomeIconComponent extends IconComponentBase {
    static readonly slug = "home";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<HomeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<HomeIconComponent, "ea-icon-home", never, {}, {}, never, never, true, never>;
}

declare class ImageIconComponent extends IconComponentBase {
    static readonly slug = "image";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageIconComponent, "ea-icon-image", never, {}, {}, never, never, true, never>;
}

declare class ImagePlusIconComponent extends IconComponentBase {
    static readonly slug = "image-plus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImagePlusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImagePlusIconComponent, "ea-icon-image-plus", never, {}, {}, never, never, true, never>;
}

declare class ImageSearchIconComponent extends IconComponentBase {
    static readonly slug = "image-search";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImageSearchIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImageSearchIconComponent, "ea-icon-image-search", never, {}, {}, never, never, true, never>;
}

declare class ImagesIconComponent extends IconComponentBase {
    static readonly slug = "images";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ImagesIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ImagesIconComponent, "ea-icon-images", never, {}, {}, never, never, true, never>;
}

declare class InboxIconComponent extends IconComponentBase {
    static readonly slug = "inbox";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InboxIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InboxIconComponent, "ea-icon-inbox", never, {}, {}, never, never, true, never>;
}

declare class InfoIconComponent extends IconComponentBase {
    static readonly slug = "info";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InfoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InfoIconComponent, "ea-icon-info", never, {}, {}, never, never, true, never>;
}

declare class InstagramIconComponent extends IconComponentBase {
    static readonly slug = "instagram";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<InstagramIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<InstagramIconComponent, "ea-icon-instagram", never, {}, {}, never, never, true, never>;
}

declare class ItalicIconComponent extends IconComponentBase {
    static readonly slug = "italic";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ItalicIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ItalicIconComponent, "ea-icon-italic", never, {}, {}, never, never, true, never>;
}

declare class KeyIconComponent extends IconComponentBase {
    static readonly slug = "key";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KeyIconComponent, "ea-icon-key", never, {}, {}, never, never, true, never>;
}

declare class KeyboardIconComponent extends IconComponentBase {
    static readonly slug = "keyboard";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyboardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KeyboardIconComponent, "ea-icon-keyboard", never, {}, {}, never, never, true, never>;
}

declare class KeyframeIconComponent extends IconComponentBase {
    static readonly slug = "keyframe";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KeyframeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KeyframeIconComponent, "ea-icon-keyframe", never, {}, {}, never, never, true, never>;
}

declare class KubernetesIconComponent extends IconComponentBase {
    static readonly slug = "kubernetes";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<KubernetesIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<KubernetesIconComponent, "ea-icon-kubernetes", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class LampIconComponent extends IconComponentBase {
    static readonly slug = "lamp";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LampIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LampIconComponent, "ea-icon-lamp", never, {}, {}, never, never, true, never>;
}

declare class LanguagesIconComponent extends IconComponentBase {
    static readonly slug = "languages";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LanguagesIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LanguagesIconComponent, "ea-icon-languages", never, {}, {}, never, never, true, never>;
}

declare class LaptopIconComponent extends IconComponentBase {
    static readonly slug = "laptop";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LaptopIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LaptopIconComponent, "ea-icon-laptop", never, {}, {}, never, never, true, never>;
}

declare class LayersIconComponent extends IconComponentBase {
    static readonly slug = "layers";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayersIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayersIconComponent, "ea-icon-layers", never, {}, {}, never, never, true, never>;
}

declare class LayoutIconComponent extends IconComponentBase {
    static readonly slug = "layout";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LayoutIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LayoutIconComponent, "ea-icon-layout", never, {}, {}, never, never, true, never>;
}

declare class LeafIconComponent extends IconComponentBase {
    static readonly slug = "leaf";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeafIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeafIconComponent, "ea-icon-leaf", never, {}, {}, never, never, true, never>;
}

declare class LeftHalfStarIconComponent extends IconComponentBase {
    static readonly slug = "left-half-star";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LeftHalfStarIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LeftHalfStarIconComponent, "ea-icon-left-half-star", never, {}, {}, never, never, true, never>;
}

declare class LifeBuoyIconComponent extends IconComponentBase {
    static readonly slug = "life-buoy";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LifeBuoyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LifeBuoyIconComponent, "ea-icon-life-buoy", never, {}, {}, never, never, true, never>;
}

declare class LightbulbIconComponent extends IconComponentBase {
    static readonly slug = "lightbulb";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LightbulbIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LightbulbIconComponent, "ea-icon-lightbulb", never, {}, {}, never, never, true, never>;
}

declare class LinkIconComponent extends IconComponentBase {
    static readonly slug = "link";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LinkIconComponent, "ea-icon-link", never, {}, {}, never, never, true, never>;
}

declare class Link2IconComponent extends IconComponentBase {
    static readonly slug = "link-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Link2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Link2IconComponent, "ea-icon-link-2", never, {}, {}, never, never, true, never>;
}

/**
 * LinkedIn icon (Feather outline).
 *
 * @remarks
 * The brand-filled LinkedIn mark lives at `<ea-icon-linkedin-2>` /
 * `Linkedin2IconComponent`.
 */
declare class LinkedinIconComponent extends IconComponentBase {
    static readonly slug = "linkedin";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LinkedinIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LinkedinIconComponent, "ea-icon-linkedin", never, {}, {}, never, never, true, never>;
}

/**
 * LinkedIn brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-linkedin>` / `LinkedinIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Linkedin2IconComponent extends IconComponentBase {
    static readonly slug = "linkedin-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Linkedin2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Linkedin2IconComponent, "ea-icon-linkedin-2", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ListIconComponent extends IconComponentBase {
    static readonly slug = "list";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListIconComponent, "ea-icon-list", never, {}, {}, never, never, true, never>;
}

declare class ListChecksIconComponent extends IconComponentBase {
    static readonly slug = "list-checks";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ListChecksIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ListChecksIconComponent, "ea-icon-list-checks", never, {}, {}, never, never, true, never>;
}

declare class LoaderIconComponent extends IconComponentBase {
    static readonly slug = "loader";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LoaderIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LoaderIconComponent, "ea-icon-loader", never, {}, {}, never, never, true, never>;
}

declare class LockIconComponent extends IconComponentBase {
    static readonly slug = "lock";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LockIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LockIconComponent, "ea-icon-lock", never, {}, {}, never, never, true, never>;
}

declare class LogInIconComponent extends IconComponentBase {
    static readonly slug = "log-in";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LogInIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LogInIconComponent, "ea-icon-log-in", never, {}, {}, never, never, true, never>;
}

declare class LogOutIconComponent extends IconComponentBase {
    static readonly slug = "log-out";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LogOutIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LogOutIconComponent, "ea-icon-log-out", never, {}, {}, never, never, true, never>;
}

declare class MailIconComponent extends IconComponentBase {
    static readonly slug = "mail";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MailIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MailIconComponent, "ea-icon-mail", never, {}, {}, never, never, true, never>;
}

declare class MailCheckIconComponent extends IconComponentBase {
    static readonly slug = "mail-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MailCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MailCheckIconComponent, "ea-icon-mail-check", never, {}, {}, never, never, true, never>;
}

declare class MapIconComponent extends IconComponentBase {
    static readonly slug = "map";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MapIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MapIconComponent, "ea-icon-map", never, {}, {}, never, never, true, never>;
}

declare class MapPinIconComponent extends IconComponentBase {
    static readonly slug = "map-pin";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MapPinIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MapPinIconComponent, "ea-icon-map-pin", never, {}, {}, never, never, true, never>;
}

declare class MastercardIconComponent extends IconComponentBase {
    static readonly slug = "mastercard";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MastercardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MastercardIconComponent, "ea-icon-mastercard", never, {}, {}, never, never, true, never>;
}

declare class MaximizeIconComponent extends IconComponentBase {
    static readonly slug = "maximize";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MaximizeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MaximizeIconComponent, "ea-icon-maximize", never, {}, {}, never, never, true, never>;
}

declare class Maximize2IconComponent extends IconComponentBase {
    static readonly slug = "maximize-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Maximize2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Maximize2IconComponent, "ea-icon-maximize-2", never, {}, {}, never, never, true, never>;
}

declare class MegaphoneIconComponent extends IconComponentBase {
    static readonly slug = "megaphone";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MegaphoneIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MegaphoneIconComponent, "ea-icon-megaphone", never, {}, {}, never, never, true, never>;
}

declare class MehIconComponent extends IconComponentBase {
    static readonly slug = "meh";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MehIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MehIconComponent, "ea-icon-meh", never, {}, {}, never, never, true, never>;
}

declare class MenuIconComponent extends IconComponentBase {
    static readonly slug = "menu";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MenuIconComponent, "ea-icon-menu", never, {}, {}, never, never, true, never>;
}

declare class MessageCircleIconComponent extends IconComponentBase {
    static readonly slug = "message-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageCircleIconComponent, "ea-icon-message-circle", never, {}, {}, never, never, true, never>;
}

declare class MessageSquareIconComponent extends IconComponentBase {
    static readonly slug = "message-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MessageSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MessageSquareIconComponent, "ea-icon-message-square", never, {}, {}, never, never, true, never>;
}

declare class MicIconComponent extends IconComponentBase {
    static readonly slug = "mic";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MicIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MicIconComponent, "ea-icon-mic", never, {}, {}, never, never, true, never>;
}

declare class MicOffIconComponent extends IconComponentBase {
    static readonly slug = "mic-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MicOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MicOffIconComponent, "ea-icon-mic-off", never, {}, {}, never, never, true, never>;
}

declare class MicroscopeIconComponent extends IconComponentBase {
    static readonly slug = "microscope";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MicroscopeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MicroscopeIconComponent, "ea-icon-microscope", never, {}, {}, never, never, true, never>;
}

declare class MicrosoftIconComponent extends IconComponentBase {
    static readonly slug = "microsoft";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MicrosoftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MicrosoftIconComponent, "ea-icon-microsoft", never, {}, {}, never, never, true, never>;
}

declare class MinimizeIconComponent extends IconComponentBase {
    static readonly slug = "minimize";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MinimizeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MinimizeIconComponent, "ea-icon-minimize", never, {}, {}, never, never, true, never>;
}

declare class Minimize2IconComponent extends IconComponentBase {
    static readonly slug = "minimize-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Minimize2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Minimize2IconComponent, "ea-icon-minimize-2", never, {}, {}, never, never, true, never>;
}

declare class MinusIconComponent extends IconComponentBase {
    static readonly slug = "minus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MinusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MinusIconComponent, "ea-icon-minus", never, {}, {}, never, never, true, never>;
}

declare class MinusCircleIconComponent extends IconComponentBase {
    static readonly slug = "minus-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MinusCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MinusCircleIconComponent, "ea-icon-minus-circle", never, {}, {}, never, never, true, never>;
}

declare class MinusSquareIconComponent extends IconComponentBase {
    static readonly slug = "minus-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MinusSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MinusSquareIconComponent, "ea-icon-minus-square", never, {}, {}, never, never, true, never>;
}

declare class MongodbIconComponent extends IconComponentBase {
    static readonly slug = "mongodb";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MongodbIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MongodbIconComponent, "ea-icon-mongodb", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class MonitorIconComponent extends IconComponentBase {
    static readonly slug = "monitor";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MonitorIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MonitorIconComponent, "ea-icon-monitor", never, {}, {}, never, never, true, never>;
}

declare class MoonIconComponent extends IconComponentBase {
    static readonly slug = "moon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MoonIconComponent, "ea-icon-moon", never, {}, {}, never, never, true, never>;
}

declare class MoreHorizontalIconComponent extends IconComponentBase {
    static readonly slug = "more-horizontal";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoreHorizontalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MoreHorizontalIconComponent, "ea-icon-more-horizontal", never, {}, {}, never, never, true, never>;
}

declare class MoreVerticalIconComponent extends IconComponentBase {
    static readonly slug = "more-vertical";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoreVerticalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MoreVerticalIconComponent, "ea-icon-more-vertical", never, {}, {}, never, never, true, never>;
}

declare class MousePointerIconComponent extends IconComponentBase {
    static readonly slug = "mouse-pointer";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MousePointerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MousePointerIconComponent, "ea-icon-mouse-pointer", never, {}, {}, never, never, true, never>;
}

declare class MoveIconComponent extends IconComponentBase {
    static readonly slug = "move";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MoveIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MoveIconComponent, "ea-icon-move", never, {}, {}, never, never, true, never>;
}

declare class MusicIconComponent extends IconComponentBase {
    static readonly slug = "music";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MusicIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<MusicIconComponent, "ea-icon-music", never, {}, {}, never, never, true, never>;
}

declare class NavigationIconComponent extends IconComponentBase {
    static readonly slug = "navigation";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NavigationIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NavigationIconComponent, "ea-icon-navigation", never, {}, {}, never, never, true, never>;
}

declare class Navigation2IconComponent extends IconComponentBase {
    static readonly slug = "navigation-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Navigation2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Navigation2IconComponent, "ea-icon-navigation-2", never, {}, {}, never, never, true, never>;
}

declare class NetlifyIconComponent extends IconComponentBase {
    static readonly slug = "netlify";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NetlifyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NetlifyIconComponent, "ea-icon-netlify", never, {}, {}, never, never, true, never>;
}

declare class NewspaperIconComponent extends IconComponentBase {
    static readonly slug = "newspaper";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NewspaperIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NewspaperIconComponent, "ea-icon-newspaper", never, {}, {}, never, never, true, never>;
}

declare class NodejsIconComponent extends IconComponentBase {
    static readonly slug = "nodejs";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NodejsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NodejsIconComponent, "ea-icon-nodejs", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NotionIconComponent extends IconComponentBase {
    static readonly slug = "notion";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NotionIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NotionIconComponent, "ea-icon-notion", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class NpmIconComponent extends IconComponentBase {
    static readonly slug = "npm";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NpmIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NpmIconComponent, "ea-icon-npm", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class OctagonIconComponent extends IconComponentBase {
    static readonly slug = "octagon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OctagonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OctagonIconComponent, "ea-icon-octagon", never, {}, {}, never, never, true, never>;
}

declare class PackageIconComponent extends IconComponentBase {
    static readonly slug = "package";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PackageIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PackageIconComponent, "ea-icon-package", never, {}, {}, never, never, true, never>;
}

declare class PaletteIconComponent extends IconComponentBase {
    static readonly slug = "palette";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaletteIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaletteIconComponent, "ea-icon-palette", never, {}, {}, never, never, true, never>;
}

declare class PaperclipIconComponent extends IconComponentBase {
    static readonly slug = "paperclip";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaperclipIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaperclipIconComponent, "ea-icon-paperclip", never, {}, {}, never, never, true, never>;
}

declare class PauseIconComponent extends IconComponentBase {
    static readonly slug = "pause";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PauseIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PauseIconComponent, "ea-icon-pause", never, {}, {}, never, never, true, never>;
}

declare class PauseCircleIconComponent extends IconComponentBase {
    static readonly slug = "pause-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PauseCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PauseCircleIconComponent, "ea-icon-pause-circle", never, {}, {}, never, never, true, never>;
}

declare class PaypalIconComponent extends IconComponentBase {
    static readonly slug = "paypal";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PaypalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PaypalIconComponent, "ea-icon-paypal", never, {}, {}, never, never, true, never>;
}

declare class PenToolIconComponent extends IconComponentBase {
    static readonly slug = "pen-tool";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PenToolIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PenToolIconComponent, "ea-icon-pen-tool", never, {}, {}, never, never, true, never>;
}

declare class PentagonIconComponent extends IconComponentBase {
    static readonly slug = "pentagon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PentagonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PentagonIconComponent, "ea-icon-pentagon", never, {}, {}, never, never, true, never>;
}

declare class PercentIconComponent extends IconComponentBase {
    static readonly slug = "percent";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PercentIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PercentIconComponent, "ea-icon-percent", never, {}, {}, never, never, true, never>;
}

declare class PhoneIconComponent extends IconComponentBase {
    static readonly slug = "phone";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneIconComponent, "ea-icon-phone", never, {}, {}, never, never, true, never>;
}

declare class PhoneCallIconComponent extends IconComponentBase {
    static readonly slug = "phone-call";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneCallIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneCallIconComponent, "ea-icon-phone-call", never, {}, {}, never, never, true, never>;
}

declare class PhoneForwardedIconComponent extends IconComponentBase {
    static readonly slug = "phone-forwarded";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneForwardedIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneForwardedIconComponent, "ea-icon-phone-forwarded", never, {}, {}, never, never, true, never>;
}

declare class PhoneIncomingIconComponent extends IconComponentBase {
    static readonly slug = "phone-incoming";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneIncomingIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneIncomingIconComponent, "ea-icon-phone-incoming", never, {}, {}, never, never, true, never>;
}

declare class PhoneMissedIconComponent extends IconComponentBase {
    static readonly slug = "phone-missed";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneMissedIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneMissedIconComponent, "ea-icon-phone-missed", never, {}, {}, never, never, true, never>;
}

declare class PhoneOffIconComponent extends IconComponentBase {
    static readonly slug = "phone-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneOffIconComponent, "ea-icon-phone-off", never, {}, {}, never, never, true, never>;
}

declare class PhoneOutgoingIconComponent extends IconComponentBase {
    static readonly slug = "phone-outgoing";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PhoneOutgoingIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PhoneOutgoingIconComponent, "ea-icon-phone-outgoing", never, {}, {}, never, never, true, never>;
}

declare class PictureInPictureIconComponent extends IconComponentBase {
    static readonly slug = "picture-in-picture";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PictureInPictureIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PictureInPictureIconComponent, "ea-icon-picture-in-picture", never, {}, {}, never, never, true, never>;
}

declare class PieChartIconComponent extends IconComponentBase {
    static readonly slug = "pie-chart";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PieChartIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PieChartIconComponent, "ea-icon-pie-chart", never, {}, {}, never, never, true, never>;
}

declare class PinIconComponent extends IconComponentBase {
    static readonly slug = "pin";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PinIconComponent, "ea-icon-pin", never, {}, {}, never, never, true, never>;
}

declare class PinterestIconComponent extends IconComponentBase {
    static readonly slug = "pinterest";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PinterestIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PinterestIconComponent, "ea-icon-pinterest", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class PlayIconComponent extends IconComponentBase {
    static readonly slug = "play";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlayIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlayIconComponent, "ea-icon-play", never, {}, {}, never, never, true, never>;
}

declare class PlayCircleIconComponent extends IconComponentBase {
    static readonly slug = "play-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlayCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlayCircleIconComponent, "ea-icon-play-circle", never, {}, {}, never, never, true, never>;
}

declare class PlaylistIconComponent extends IconComponentBase {
    static readonly slug = "playlist";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlaylistIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlaylistIconComponent, "ea-icon-playlist", never, {}, {}, never, never, true, never>;
}

declare class PlugIconComponent extends IconComponentBase {
    static readonly slug = "plug";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlugIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlugIconComponent, "ea-icon-plug", never, {}, {}, never, never, true, never>;
}

declare class PlusIconComponent extends IconComponentBase {
    static readonly slug = "plus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlusIconComponent, "ea-icon-plus", never, {}, {}, never, never, true, never>;
}

declare class PlusCircleIconComponent extends IconComponentBase {
    static readonly slug = "plus-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlusCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlusCircleIconComponent, "ea-icon-plus-circle", never, {}, {}, never, never, true, never>;
}

declare class PlusSquareIconComponent extends IconComponentBase {
    static readonly slug = "plus-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PlusSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PlusSquareIconComponent, "ea-icon-plus-square", never, {}, {}, never, never, true, never>;
}

declare class PocketIconComponent extends IconComponentBase {
    static readonly slug = "pocket";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PocketIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PocketIconComponent, "ea-icon-pocket", never, {}, {}, never, never, true, never>;
}

declare class PowerIconComponent extends IconComponentBase {
    static readonly slug = "power";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PowerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PowerIconComponent, "ea-icon-power", never, {}, {}, never, never, true, never>;
}

declare class PrinterIconComponent extends IconComponentBase {
    static readonly slug = "printer";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PrinterIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PrinterIconComponent, "ea-icon-printer", never, {}, {}, never, never, true, never>;
}

declare class PythonIconComponent extends IconComponentBase {
    static readonly slug = "python";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<PythonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<PythonIconComponent, "ea-icon-python", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class QrCodeIconComponent extends IconComponentBase {
    static readonly slug = "qr-code";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QrCodeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QrCodeIconComponent, "ea-icon-qr-code", never, {}, {}, never, never, true, never>;
}

declare class QuestionExclamationMarkIconComponent extends IconComponentBase {
    static readonly slug = "question-exclamation-mark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuestionExclamationMarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuestionExclamationMarkIconComponent, "ea-icon-question-exclamation-mark", never, {}, {}, never, never, true, never>;
}

declare class QuestionMarkIconComponent extends IconComponentBase {
    static readonly slug = "question-mark";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QuestionMarkIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QuestionMarkIconComponent, "ea-icon-question-mark", never, {}, {}, never, never, true, never>;
}

declare class RadioIconComponent extends IconComponentBase {
    static readonly slug = "radio";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RadioIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RadioIconComponent, "ea-icon-radio", never, {}, {}, never, never, true, never>;
}

declare class ReactIconComponent extends IconComponentBase {
    static readonly slug = "react";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReactIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReactIconComponent, "ea-icon-react", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ReceiptIconComponent extends IconComponentBase {
    static readonly slug = "receipt";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ReceiptIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ReceiptIconComponent, "ea-icon-receipt", never, {}, {}, never, never, true, never>;
}

declare class RecordIconComponent extends IconComponentBase {
    static readonly slug = "record";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RecordIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RecordIconComponent, "ea-icon-record", never, {}, {}, never, never, true, never>;
}

declare class RectangleHorizontalIconComponent extends IconComponentBase {
    static readonly slug = "rectangle-horizontal";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RectangleHorizontalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RectangleHorizontalIconComponent, "ea-icon-rectangle-horizontal", never, {}, {}, never, never, true, never>;
}

declare class RectangleVerticalIconComponent extends IconComponentBase {
    static readonly slug = "rectangle-vertical";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RectangleVerticalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RectangleVerticalIconComponent, "ea-icon-rectangle-vertical", never, {}, {}, never, never, true, never>;
}

declare class RedditIconComponent extends IconComponentBase {
    static readonly slug = "reddit";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RedditIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RedditIconComponent, "ea-icon-reddit", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class RedoIconComponent extends IconComponentBase {
    static readonly slug = "redo";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RedoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RedoIconComponent, "ea-icon-redo", never, {}, {}, never, never, true, never>;
}

declare class RefreshCcwIconComponent extends IconComponentBase {
    static readonly slug = "refresh-ccw";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RefreshCcwIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RefreshCcwIconComponent, "ea-icon-refresh-ccw", never, {}, {}, never, never, true, never>;
}

declare class RefreshCwIconComponent extends IconComponentBase {
    static readonly slug = "refresh-cw";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RefreshCwIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RefreshCwIconComponent, "ea-icon-refresh-cw", never, {}, {}, never, never, true, never>;
}

declare class RepeatIconComponent extends IconComponentBase {
    static readonly slug = "repeat";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RepeatIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RepeatIconComponent, "ea-icon-repeat", never, {}, {}, never, never, true, never>;
}

declare class RewindIconComponent extends IconComponentBase {
    static readonly slug = "rewind";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RewindIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RewindIconComponent, "ea-icon-rewind", never, {}, {}, never, never, true, never>;
}

declare class RightHalfStarIconComponent extends IconComponentBase {
    static readonly slug = "right-half-star";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RightHalfStarIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RightHalfStarIconComponent, "ea-icon-right-half-star", never, {}, {}, never, never, true, never>;
}

declare class RocketIconComponent extends IconComponentBase {
    static readonly slug = "rocket";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RocketIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RocketIconComponent, "ea-icon-rocket", never, {}, {}, never, never, true, never>;
}

declare class RotateCcwIconComponent extends IconComponentBase {
    static readonly slug = "rotate-ccw";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RotateCcwIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RotateCcwIconComponent, "ea-icon-rotate-ccw", never, {}, {}, never, never, true, never>;
}

declare class RotateCcwSquareIconComponent extends IconComponentBase {
    static readonly slug = "rotate-ccw-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RotateCcwSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RotateCcwSquareIconComponent, "ea-icon-rotate-ccw-square", never, {}, {}, never, never, true, never>;
}

declare class RotateCwIconComponent extends IconComponentBase {
    static readonly slug = "rotate-cw";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RotateCwIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RotateCwIconComponent, "ea-icon-rotate-cw", never, {}, {}, never, never, true, never>;
}

declare class RowsIconComponent extends IconComponentBase {
    static readonly slug = "rows";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RowsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RowsIconComponent, "ea-icon-rows", never, {}, {}, never, never, true, never>;
}

declare class RssIconComponent extends IconComponentBase {
    static readonly slug = "rss";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<RssIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<RssIconComponent, "ea-icon-rss", never, {}, {}, never, never, true, never>;
}

declare class SaveIconComponent extends IconComponentBase {
    static readonly slug = "save";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SaveIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SaveIconComponent, "ea-icon-save", never, {}, {}, never, never, true, never>;
}

declare class ScanIconComponent extends IconComponentBase {
    static readonly slug = "scan";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScanIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScanIconComponent, "ea-icon-scan", never, {}, {}, never, never, true, never>;
}

declare class ScissorsIconComponent extends IconComponentBase {
    static readonly slug = "scissors";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ScissorsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ScissorsIconComponent, "ea-icon-scissors", never, {}, {}, never, never, true, never>;
}

declare class SecondPlaceMedalIconComponent extends IconComponentBase {
    static readonly slug = "second-place-medal";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SecondPlaceMedalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SecondPlaceMedalIconComponent, "ea-icon-second-place-medal", never, {}, {}, never, never, true, never>;
}

declare class SendIconComponent extends IconComponentBase {
    static readonly slug = "send";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SendIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SendIconComponent, "ea-icon-send", never, {}, {}, never, never, true, never>;
}

declare class ServerIconComponent extends IconComponentBase {
    static readonly slug = "server";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ServerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ServerIconComponent, "ea-icon-server", never, {}, {}, never, never, true, never>;
}

declare class SettingsIconComponent extends IconComponentBase {
    static readonly slug = "settings";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SettingsIconComponent, "ea-icon-settings", never, {}, {}, never, never, true, never>;
}

declare class ShareIconComponent extends IconComponentBase {
    static readonly slug = "share";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShareIconComponent, "ea-icon-share", never, {}, {}, never, never, true, never>;
}

declare class ShieldIconComponent extends IconComponentBase {
    static readonly slug = "shield";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShieldIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShieldIconComponent, "ea-icon-shield", never, {}, {}, never, never, true, never>;
}

declare class ShieldCheckIconComponent extends IconComponentBase {
    static readonly slug = "shield-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShieldCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShieldCheckIconComponent, "ea-icon-shield-check", never, {}, {}, never, never, true, never>;
}

declare class ShieldOffIconComponent extends IconComponentBase {
    static readonly slug = "shield-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShieldOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShieldOffIconComponent, "ea-icon-shield-off", never, {}, {}, never, never, true, never>;
}

declare class ShopifyIconComponent extends IconComponentBase {
    static readonly slug = "shopify";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShopifyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShopifyIconComponent, "ea-icon-shopify", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ShoppingBagIconComponent extends IconComponentBase {
    static readonly slug = "shopping-bag";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShoppingBagIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShoppingBagIconComponent, "ea-icon-shopping-bag", never, {}, {}, never, never, true, never>;
}

declare class ShoppingCartIconComponent extends IconComponentBase {
    static readonly slug = "shopping-cart";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShoppingCartIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShoppingCartIconComponent, "ea-icon-shopping-cart", never, {}, {}, never, never, true, never>;
}

declare class ShuffleIconComponent extends IconComponentBase {
    static readonly slug = "shuffle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ShuffleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ShuffleIconComponent, "ea-icon-shuffle", never, {}, {}, never, never, true, never>;
}

declare class SidebarIconComponent extends IconComponentBase {
    static readonly slug = "sidebar";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SidebarIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SidebarIconComponent, "ea-icon-sidebar", never, {}, {}, never, never, true, never>;
}

declare class SkipBackIconComponent extends IconComponentBase {
    static readonly slug = "skip-back";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkipBackIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkipBackIconComponent, "ea-icon-skip-back", never, {}, {}, never, never, true, never>;
}

declare class SkipForwardIconComponent extends IconComponentBase {
    static readonly slug = "skip-forward";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SkipForwardIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SkipForwardIconComponent, "ea-icon-skip-forward", never, {}, {}, never, never, true, never>;
}

/**
 * Slack icon (Feather outline).
 *
 * @remarks
 * The brand-filled Slack mark lives at `<ea-icon-slack-2>` /
 * `Slack2IconComponent`.
 */
declare class SlackIconComponent extends IconComponentBase {
    static readonly slug = "slack";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlackIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlackIconComponent, "ea-icon-slack", never, {}, {}, never, never, true, never>;
}

/**
 * Slack brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-slack>` / `SlackIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Slack2IconComponent extends IconComponentBase {
    static readonly slug = "slack-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Slack2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Slack2IconComponent, "ea-icon-slack-2", never, {}, {}, never, never, true, never>;
}

declare class SlashIconComponent extends IconComponentBase {
    static readonly slug = "slash";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlashIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlashIconComponent, "ea-icon-slash", never, {}, {}, never, never, true, never>;
}

declare class SlidersIconComponent extends IconComponentBase {
    static readonly slug = "sliders";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlidersIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlidersIconComponent, "ea-icon-sliders", never, {}, {}, never, never, true, never>;
}

declare class SmartphoneIconComponent extends IconComponentBase {
    static readonly slug = "smartphone";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmartphoneIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmartphoneIconComponent, "ea-icon-smartphone", never, {}, {}, never, never, true, never>;
}

declare class SmileIconComponent extends IconComponentBase {
    static readonly slug = "smile";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SmileIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SmileIconComponent, "ea-icon-smile", never, {}, {}, never, never, true, never>;
}

declare class SnowflakeIconComponent extends IconComponentBase {
    static readonly slug = "snowflake";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnowflakeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SnowflakeIconComponent, "ea-icon-snowflake", never, {}, {}, never, never, true, never>;
}

declare class SoccerBallIconComponent extends IconComponentBase {
    static readonly slug = "soccer-ball";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SoccerBallIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SoccerBallIconComponent, "ea-icon-soccer-ball", never, {}, {}, never, never, true, never>;
}

declare class SparklesIconComponent extends IconComponentBase {
    static readonly slug = "sparkles";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SparklesIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SparklesIconComponent, "ea-icon-sparkles", never, {}, {}, never, never, true, never>;
}

declare class SpeakerIconComponent extends IconComponentBase {
    static readonly slug = "speaker";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpeakerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpeakerIconComponent, "ea-icon-speaker", never, {}, {}, never, never, true, never>;
}

declare class SpotifyIconComponent extends IconComponentBase {
    static readonly slug = "spotify";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SpotifyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SpotifyIconComponent, "ea-icon-spotify", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SquareIconComponent extends IconComponentBase {
    static readonly slug = "square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SquareIconComponent, "ea-icon-square", never, {}, {}, never, never, true, never>;
}

declare class StarIconComponent extends IconComponentBase {
    static readonly slug = "star";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StarIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StarIconComponent, "ea-icon-star", never, {}, {}, never, never, true, never>;
}

declare class StopCircleIconComponent extends IconComponentBase {
    static readonly slug = "stop-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StopCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StopCircleIconComponent, "ea-icon-stop-circle", never, {}, {}, never, never, true, never>;
}

declare class StripeIconComponent extends IconComponentBase {
    static readonly slug = "stripe";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StripeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StripeIconComponent, "ea-icon-stripe", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class SubtitlesIconComponent extends IconComponentBase {
    static readonly slug = "subtitles";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SubtitlesIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SubtitlesIconComponent, "ea-icon-subtitles", never, {}, {}, never, never, true, never>;
}

declare class SunIconComponent extends IconComponentBase {
    static readonly slug = "sun";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SunIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SunIconComponent, "ea-icon-sun", never, {}, {}, never, never, true, never>;
}

declare class SunriseIconComponent extends IconComponentBase {
    static readonly slug = "sunrise";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SunriseIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SunriseIconComponent, "ea-icon-sunrise", never, {}, {}, never, never, true, never>;
}

declare class SunsetIconComponent extends IconComponentBase {
    static readonly slug = "sunset";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SunsetIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SunsetIconComponent, "ea-icon-sunset", never, {}, {}, never, never, true, never>;
}

declare class SvelteIconComponent extends IconComponentBase {
    static readonly slug = "svelte";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvelteIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SvelteIconComponent, "ea-icon-svelte", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TableIconComponent extends IconComponentBase {
    static readonly slug = "table";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TableIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TableIconComponent, "ea-icon-table", never, {}, {}, never, never, true, never>;
}

declare class TabletIconComponent extends IconComponentBase {
    static readonly slug = "tablet";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TabletIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TabletIconComponent, "ea-icon-tablet", never, {}, {}, never, never, true, never>;
}

declare class TagIconComponent extends IconComponentBase {
    static readonly slug = "tag";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TagIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TagIconComponent, "ea-icon-tag", never, {}, {}, never, never, true, never>;
}

declare class TailwindIconComponent extends IconComponentBase {
    static readonly slug = "tailwind";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TailwindIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TailwindIconComponent, "ea-icon-tailwind", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TargetIconComponent extends IconComponentBase {
    static readonly slug = "target";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TargetIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TargetIconComponent, "ea-icon-target", never, {}, {}, never, never, true, never>;
}

declare class TelegramIconComponent extends IconComponentBase {
    static readonly slug = "telegram";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TelegramIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TelegramIconComponent, "ea-icon-telegram", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TerminalIconComponent extends IconComponentBase {
    static readonly slug = "terminal";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TerminalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TerminalIconComponent, "ea-icon-terminal", never, {}, {}, never, never, true, never>;
}

declare class ThermometerIconComponent extends IconComponentBase {
    static readonly slug = "thermometer";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThermometerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThermometerIconComponent, "ea-icon-thermometer", never, {}, {}, never, never, true, never>;
}

declare class ThirdPlaceMedalIconComponent extends IconComponentBase {
    static readonly slug = "third-place-medal";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThirdPlaceMedalIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThirdPlaceMedalIconComponent, "ea-icon-third-place-medal", never, {}, {}, never, never, true, never>;
}

declare class ThreadsIconComponent extends IconComponentBase {
    static readonly slug = "threads";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThreadsIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThreadsIconComponent, "ea-icon-threads", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ThumbsDownIconComponent extends IconComponentBase {
    static readonly slug = "thumbs-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThumbsDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThumbsDownIconComponent, "ea-icon-thumbs-down", never, {}, {}, never, never, true, never>;
}

declare class ThumbsUpIconComponent extends IconComponentBase {
    static readonly slug = "thumbs-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ThumbsUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ThumbsUpIconComponent, "ea-icon-thumbs-up", never, {}, {}, never, never, true, never>;
}

declare class TiktokIconComponent extends IconComponentBase {
    static readonly slug = "tiktok";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TiktokIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TiktokIconComponent, "ea-icon-tiktok", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TimecodeIconComponent extends IconComponentBase {
    static readonly slug = "timecode";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimecodeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimecodeIconComponent, "ea-icon-timecode", never, {}, {}, never, never, true, never>;
}

declare class TimerIconComponent extends IconComponentBase {
    static readonly slug = "timer";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TimerIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TimerIconComponent, "ea-icon-timer", never, {}, {}, never, never, true, never>;
}

declare class ToggleLeftIconComponent extends IconComponentBase {
    static readonly slug = "toggle-left";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleLeftIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleLeftIconComponent, "ea-icon-toggle-left", never, {}, {}, never, never, true, never>;
}

declare class ToggleRightIconComponent extends IconComponentBase {
    static readonly slug = "toggle-right";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToggleRightIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToggleRightIconComponent, "ea-icon-toggle-right", never, {}, {}, never, never, true, never>;
}

declare class ToolIconComponent extends IconComponentBase {
    static readonly slug = "tool";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ToolIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ToolIconComponent, "ea-icon-tool", never, {}, {}, never, never, true, never>;
}

declare class TranscodeIconComponent extends IconComponentBase {
    static readonly slug = "transcode";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranscodeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TranscodeIconComponent, "ea-icon-transcode", never, {}, {}, never, never, true, never>;
}

declare class TrashIconComponent extends IconComponentBase {
    static readonly slug = "trash";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrashIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrashIconComponent, "ea-icon-trash", never, {}, {}, never, never, true, never>;
}

declare class Trash2IconComponent extends IconComponentBase {
    static readonly slug = "trash-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Trash2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Trash2IconComponent, "ea-icon-trash-2", never, {}, {}, never, never, true, never>;
}

declare class TrelloIconComponent extends IconComponentBase {
    static readonly slug = "trello";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrelloIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrelloIconComponent, "ea-icon-trello", never, {}, {}, never, never, true, never>;
}

declare class TrendingDownIconComponent extends IconComponentBase {
    static readonly slug = "trending-down";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrendingDownIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrendingDownIconComponent, "ea-icon-trending-down", never, {}, {}, never, never, true, never>;
}

declare class TrendingUpIconComponent extends IconComponentBase {
    static readonly slug = "trending-up";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrendingUpIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrendingUpIconComponent, "ea-icon-trending-up", never, {}, {}, never, never, true, never>;
}

declare class TriangleIconComponent extends IconComponentBase {
    static readonly slug = "triangle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TriangleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TriangleIconComponent, "ea-icon-triangle", never, {}, {}, never, never, true, never>;
}

declare class TrimIconComponent extends IconComponentBase {
    static readonly slug = "trim";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrimIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrimIconComponent, "ea-icon-trim", never, {}, {}, never, never, true, never>;
}

declare class TrophyIconComponent extends IconComponentBase {
    static readonly slug = "trophy";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TrophyIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TrophyIconComponent, "ea-icon-trophy", never, {}, {}, never, never, true, never>;
}

declare class TruckIconComponent extends IconComponentBase {
    static readonly slug = "truck";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TruckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TruckIconComponent, "ea-icon-truck", never, {}, {}, never, never, true, never>;
}

declare class TvIconComponent extends IconComponentBase {
    static readonly slug = "tv";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TvIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TvIconComponent, "ea-icon-tv", never, {}, {}, never, never, true, never>;
}

/**
 * Twitch icon (Feather outline).
 *
 * @remarks
 * The brand-filled Twitch mark lives at `<ea-icon-twitch-2>` /
 * `Twitch2IconComponent`.
 */
declare class TwitchIconComponent extends IconComponentBase {
    static readonly slug = "twitch";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TwitchIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TwitchIconComponent, "ea-icon-twitch", never, {}, {}, never, never, true, never>;
}

/**
 * Twitch brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-twitch>` / `TwitchIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Twitch2IconComponent extends IconComponentBase {
    static readonly slug = "twitch-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Twitch2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Twitch2IconComponent, "ea-icon-twitch-2", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class TwitterIconComponent extends IconComponentBase {
    static readonly slug = "twitter";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TwitterIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TwitterIconComponent, "ea-icon-twitter", never, {}, {}, never, never, true, never>;
}

declare class TypeIconComponent extends IconComponentBase {
    static readonly slug = "type";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TypeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TypeIconComponent, "ea-icon-type", never, {}, {}, never, never, true, never>;
}

declare class UmbrellaIconComponent extends IconComponentBase {
    static readonly slug = "umbrella";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UmbrellaIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UmbrellaIconComponent, "ea-icon-umbrella", never, {}, {}, never, never, true, never>;
}

declare class UnderlineIconComponent extends IconComponentBase {
    static readonly slug = "underline";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UnderlineIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UnderlineIconComponent, "ea-icon-underline", never, {}, {}, never, never, true, never>;
}

declare class UndoIconComponent extends IconComponentBase {
    static readonly slug = "undo";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UndoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UndoIconComponent, "ea-icon-undo", never, {}, {}, never, never, true, never>;
}

declare class UnlockIconComponent extends IconComponentBase {
    static readonly slug = "unlock";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UnlockIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UnlockIconComponent, "ea-icon-unlock", never, {}, {}, never, never, true, never>;
}

declare class UploadIconComponent extends IconComponentBase {
    static readonly slug = "upload";
    static readonly category: IconCategory;
    static readonly defaultStrokeWidth = 1.5;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploadIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UploadIconComponent, "ea-icon-upload", never, {}, {}, never, never, true, never>;
}

declare class UploadCloudIconComponent extends IconComponentBase {
    static readonly slug = "upload-cloud";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UploadCloudIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UploadCloudIconComponent, "ea-icon-upload-cloud", never, {}, {}, never, never, true, never>;
}

declare class UserIconComponent extends IconComponentBase {
    static readonly slug = "user";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserIconComponent, "ea-icon-user", never, {}, {}, never, never, true, never>;
}

declare class UserCheckIconComponent extends IconComponentBase {
    static readonly slug = "user-check";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserCheckIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserCheckIconComponent, "ea-icon-user-check", never, {}, {}, never, never, true, never>;
}

declare class UserMinusIconComponent extends IconComponentBase {
    static readonly slug = "user-minus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserMinusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserMinusIconComponent, "ea-icon-user-minus", never, {}, {}, never, never, true, never>;
}

declare class UserPlusIconComponent extends IconComponentBase {
    static readonly slug = "user-plus";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserPlusIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserPlusIconComponent, "ea-icon-user-plus", never, {}, {}, never, never, true, never>;
}

declare class UserXIconComponent extends IconComponentBase {
    static readonly slug = "user-x";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UserXIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UserXIconComponent, "ea-icon-user-x", never, {}, {}, never, never, true, never>;
}

declare class UsersIconComponent extends IconComponentBase {
    static readonly slug = "users";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<UsersIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<UsersIconComponent, "ea-icon-users", never, {}, {}, never, never, true, never>;
}

declare class VercelIconComponent extends IconComponentBase {
    static readonly slug = "vercel";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VercelIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VercelIconComponent, "ea-icon-vercel", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class VideoIconComponent extends IconComponentBase {
    static readonly slug = "video";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VideoIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VideoIconComponent, "ea-icon-video", never, {}, {}, never, never, true, never>;
}

declare class VideoOffIconComponent extends IconComponentBase {
    static readonly slug = "video-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VideoOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VideoOffIconComponent, "ea-icon-video-off", never, {}, {}, never, never, true, never>;
}

declare class VoicemailIconComponent extends IconComponentBase {
    static readonly slug = "voicemail";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VoicemailIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VoicemailIconComponent, "ea-icon-voicemail", never, {}, {}, never, never, true, never>;
}

declare class VolumeIconComponent extends IconComponentBase {
    static readonly slug = "volume";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VolumeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VolumeIconComponent, "ea-icon-volume", never, {}, {}, never, never, true, never>;
}

declare class Volume1IconComponent extends IconComponentBase {
    static readonly slug = "volume-1";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Volume1IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Volume1IconComponent, "ea-icon-volume-1", never, {}, {}, never, never, true, never>;
}

declare class Volume2IconComponent extends IconComponentBase {
    static readonly slug = "volume-2";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Volume2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Volume2IconComponent, "ea-icon-volume-2", never, {}, {}, never, never, true, never>;
}

declare class VolumeXIconComponent extends IconComponentBase {
    static readonly slug = "volume-x";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VolumeXIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VolumeXIconComponent, "ea-icon-volume-x", never, {}, {}, never, never, true, never>;
}

declare class VueIconComponent extends IconComponentBase {
    static readonly slug = "vue";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<VueIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<VueIconComponent, "ea-icon-vue", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class WalletIconComponent extends IconComponentBase {
    static readonly slug = "wallet";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WalletIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WalletIconComponent, "ea-icon-wallet", never, {}, {}, never, never, true, never>;
}

declare class WandIconComponent extends IconComponentBase {
    static readonly slug = "wand";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WandIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WandIconComponent, "ea-icon-wand", never, {}, {}, never, never, true, never>;
}

declare class WatchIconComponent extends IconComponentBase {
    static readonly slug = "watch";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WatchIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WatchIconComponent, "ea-icon-watch", never, {}, {}, never, never, true, never>;
}

declare class WaveformIconComponent extends IconComponentBase {
    static readonly slug = "waveform";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WaveformIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WaveformIconComponent, "ea-icon-waveform", never, {}, {}, never, never, true, never>;
}

declare class WhatsappIconComponent extends IconComponentBase {
    static readonly slug = "whatsapp";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WhatsappIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WhatsappIconComponent, "ea-icon-whatsapp", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class WifiIconComponent extends IconComponentBase {
    static readonly slug = "wifi";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WifiIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WifiIconComponent, "ea-icon-wifi", never, {}, {}, never, never, true, never>;
}

declare class WifiOffIconComponent extends IconComponentBase {
    static readonly slug = "wifi-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WifiOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WifiOffIconComponent, "ea-icon-wifi-off", never, {}, {}, never, never, true, never>;
}

declare class WindIconComponent extends IconComponentBase {
    static readonly slug = "wind";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WindIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WindIconComponent, "ea-icon-wind", never, {}, {}, never, never, true, never>;
}

declare class WordpressIconComponent extends IconComponentBase {
    static readonly slug = "wordpress";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<WordpressIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<WordpressIconComponent, "ea-icon-wordpress", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class XIconComponent extends IconComponentBase {
    static readonly slug = "x";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XIconComponent, "ea-icon-x", never, {}, {}, never, never, true, never>;
}

declare class XCircleIconComponent extends IconComponentBase {
    static readonly slug = "x-circle";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XCircleIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XCircleIconComponent, "ea-icon-x-circle", never, {}, {}, never, never, true, never>;
}

declare class XOctagonIconComponent extends IconComponentBase {
    static readonly slug = "x-octagon";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XOctagonIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XOctagonIconComponent, "ea-icon-x-octagon", never, {}, {}, never, never, true, never>;
}

declare class XSquareIconComponent extends IconComponentBase {
    static readonly slug = "x-square";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XSquareIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XSquareIconComponent, "ea-icon-x-square", never, {}, {}, never, never, true, never>;
}

declare class XTwitterIconComponent extends IconComponentBase {
    static readonly slug = "x-twitter";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<XTwitterIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<XTwitterIconComponent, "ea-icon-x-twitter", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

/**
 * YouTube icon (Feather outline).
 *
 * @remarks
 * The brand-filled YouTube mark lives at `<ea-icon-youtube-2>` /
 * `Youtube2IconComponent`.
 */
declare class YoutubeIconComponent extends IconComponentBase {
    static readonly slug = "youtube";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<YoutubeIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<YoutubeIconComponent, "ea-icon-youtube", never, {}, {}, never, never, true, never>;
}

/**
 * YouTube brand mark (Eagami brand-filled).
 *
 * @remarks
 * The Feather outline lives at `<ea-icon-youtube>` / `YoutubeIconComponent`.
 * Set the `brand` input to render in the official brand colour.
 */
declare class Youtube2IconComponent extends IconComponentBase {
    static readonly slug = "youtube-2";
    static readonly category: IconCategory;
    static readonly isBrand = true;
    static readonly tags: ReadonlyArray<string>;
    readonly brand: _angular_core.InputSignal<boolean>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Youtube2IconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<Youtube2IconComponent, "ea-icon-youtube-2", never, { "brand": { "alias": "brand"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
}

declare class ZapIconComponent extends IconComponentBase {
    static readonly slug = "zap";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZapIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZapIconComponent, "ea-icon-zap", never, {}, {}, never, never, true, never>;
}

declare class ZapOffIconComponent extends IconComponentBase {
    static readonly slug = "zap-off";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZapOffIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZapOffIconComponent, "ea-icon-zap-off", never, {}, {}, never, never, true, never>;
}

declare class ZoomInIconComponent extends IconComponentBase {
    static readonly slug = "zoom-in";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZoomInIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZoomInIconComponent, "ea-icon-zoom-in", never, {}, {}, never, never, true, never>;
}

declare class ZoomOutIconComponent extends IconComponentBase {
    static readonly slug = "zoom-out";
    static readonly category: IconCategory;
    static readonly tags: ReadonlyArray<string>;
    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ZoomOutIconComponent, never>;
    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ZoomOutIconComponent, "ea-icon-zoom-out", never, {}, {}, never, never, true, never>;
}

export { AccordionComponent, AccordionItemComponent, ActivityIconComponent, AirplayIconComponent, AlertCircleIconComponent, AlertComponent, AlertOctagonIconComponent, AlertTriangleIconComponent, AlignCenterIconComponent, AlignJustifyIconComponent, AlignLeftIconComponent, AlignRightIconComponent, AnchorIconComponent, AndroidIconComponent, AngularIconComponent, AnthropicIconComponent, ApertureIconComponent, ArchiveIconComponent, ArrayIconComponent, ArrowDownCircleIconComponent, ArrowDownIconComponent, ArrowDownLeftIconComponent, ArrowDownRightIconComponent, ArrowLeftCircleIconComponent, ArrowLeftIconComponent, ArrowRightCircleIconComponent, ArrowRightIconComponent, ArrowUpCircleIconComponent, ArrowUpIconComponent, ArrowUpLeftIconComponent, ArrowUpRightIconComponent, AspectRatioIconComponent, AtSignIconComponent, AutocompleteComponent, AvatarComponent, AvatarEditorComponent, AwardIconComponent, BadgeCheckIconComponent, BadgeComponent, BarChart2IconComponent, BarChartIconComponent, BatteryChargingIconComponent, BatteryIconComponent, BellIconComponent, BellOffIconComponent, BellRingIconComponent, BitcoinIconComponent, BlueskyIconComponent, BluetoothIconComponent, BoldIconComponent, BookIconComponent, BookOpenIconComponent, BookmarkCheckIconComponent, BookmarkIconComponent, BookmarkPlusIconComponent, BotIconComponent, BottleIconComponent, BoxIconComponent, BrainIconComponent, BreadcrumbsComponent, BriefcaseIconComponent, BugIconComponent, BuildingIconComponent, ButtonComponent, CalculatorIconComponent, CalendarCheckIconComponent, CalendarDaysIconComponent, CalendarIconComponent, CameraIconComponent, CameraOffIconComponent, CandleIconComponent, CardComponent, CastIconComponent, CheckCircleIconComponent, CheckIconComponent, CheckSquareIconComponent, CheckboxComponent, ChevronDownIconComponent, ChevronLeftIconComponent, ChevronRightIconComponent, ChevronUpIconComponent, ChevronsDownIconComponent, ChevronsLeftIconComponent, ChevronsRightIconComponent, ChevronsUpDownIconComponent, ChevronsUpIconComponent, ChromeIconComponent, CircleIconComponent, ClapperboardIconComponent, ClipboardCheckIconComponent, ClipboardIconComponent, ClipboardListIconComponent, ClockIconComponent, CloudDrizzleIconComponent, CloudIconComponent, CloudLightningIconComponent, CloudOffIconComponent, CloudRainIconComponent, CloudSnowIconComponent, CloudflareIconComponent, CodeIconComponent, CodeInputComponent, CodepenIconComponent, CodesandboxIconComponent, CoffeeIconComponent, CoinsIconComponent, ColorPickerComponent, ColumnsIconComponent, CommandIconComponent, CommandPaletteComponent, CompassIconComponent, ContrastIconComponent, CopyIconComponent, CornerDownLeftIconComponent, CornerDownRightIconComponent, CornerLeftDownIconComponent, CornerLeftUpIconComponent, CornerRightDownIconComponent, CornerRightUpIconComponent, CornerUpLeftIconComponent, CornerUpRightIconComponent, CpuIconComponent, CreditCardIconComponent, CropIconComponent, CrosshairIconComponent, DEFAULT_PALETTE_ROLES, DataTableComponent, DatabaseIconComponent, DatePickerComponent, DeleteIconComponent, DialogComponent, Dice1IconComponent, Dice2IconComponent, Dice3IconComponent, Dice4IconComponent, Dice5IconComponent, Dice6IconComponent, DiscIconComponent, DiscordIconComponent, DivideCircleIconComponent, DivideIconComponent, DivideSquareIconComponent, DividerComponent, DockerIconComponent, DollarSignIconComponent, DoubleExclamationMarkIconComponent, DoubleQuestionMarkIconComponent, DownloadCloudIconComponent, DownloadIconComponent, DrawerComponent, DribbbleIconComponent, DropboxIconComponent, DropdownComponent, DropletIconComponent, EAGAMI_ALL_LOCALES, EAGAMI_I18N_CONFIG, EAGAMI_LOCALES, EAGAMI_LOCALE_META, EagamiI18nService, EagamiIconComponent, EagamiWordmarkComponent, Edit2IconComponent, Edit3IconComponent, EditIconComponent, EmptyStateComponent, ExclamationMarkIconComponent, ExclamationQuestionMarkIconComponent, ExternalLinkIconComponent, EyeIconComponent, EyeOffIconComponent, Facebook2IconComponent, FacebookIconComponent, FastForwardIconComponent, FeatherIconComponent, FieldLabelComponent, FieldMessagesComponent, Figma2IconComponent, FigmaIconComponent, FileAudioIconComponent, FileCheckIconComponent, FileIconComponent, FileImageIconComponent, FileMinusIconComponent, FilePdfIconComponent, FilePlusIconComponent, FileTextIconComponent, FileUploaderComponent, FileVideoIconComponent, FilmIconComponent, FilterIconComponent, FilterXIconComponent, FingerprintIconComponent, FirstPlaceMedalIconComponent, FlagIconComponent, FlameIconComponent, FolderIconComponent, FolderMinusIconComponent, FolderOpenIconComponent, FolderPlusIconComponent, FormFieldComponent, FramerIconComponent, FrownIconComponent, GaugeIconComponent, GeminiIconComponent, GiftIconComponent, GitBranchIconComponent, GitCommitIconComponent, GitCompareIconComponent, GitMergeIconComponent, GitPullRequestIconComponent, Github2IconComponent, GithubIconComponent, GitlabIconComponent, GlobeIconComponent, GoogleIconComponent, GridIconComponent, HalfCircleIconComponent, HalfHeartIconComponent, HardDriveIconComponent, HashIconComponent, HeadphonesIconComponent, HeartIconComponent, HelpCircleIconComponent, HeptagonIconComponent, HexagonIconComponent, HistoryIconComponent, HomeIconComponent, ICONS, IconComponentBase, ImageIconComponent, ImagePlusIconComponent, ImageSearchIconComponent, ImagesIconComponent, InboxIconComponent, InfoIconComponent, InputComponent, InstagramIconComponent, ItalicIconComponent, KeyIconComponent, KeyboardIconComponent, KeyframeIconComponent, KubernetesIconComponent, LampIconComponent, LanguagesIconComponent, LaptopIconComponent, LayersIconComponent, LayoutIconComponent, LeafIconComponent, LeftHalfStarIconComponent, LifeBuoyIconComponent, LightbulbIconComponent, Link2IconComponent, LinkIconComponent, Linkedin2IconComponent, LinkedinIconComponent, ListChecksIconComponent, ListIconComponent, LoaderIconComponent, LockIconComponent, LogInIconComponent, LogOutIconComponent, MailCheckIconComponent, MailIconComponent, MapIconComponent, MapPinIconComponent, MastercardIconComponent, Maximize2IconComponent, MaximizeIconComponent, MegaphoneIconComponent, MehIconComponent, MenuComponent, MenuIconComponent, MenuItemComponent, MenuTriggerDirective, MessageCircleIconComponent, MessageSquareIconComponent, MicIconComponent, MicOffIconComponent, MicroscopeIconComponent, MicrosoftIconComponent, Minimize2IconComponent, MinimizeIconComponent, MinusCircleIconComponent, MinusIconComponent, MinusSquareIconComponent, MongodbIconComponent, MonitorIconComponent, MoonIconComponent, MoreHorizontalIconComponent, MoreVerticalIconComponent, MousePointerIconComponent, MoveIconComponent, MultiSelectComponent, MusicIconComponent, Navigation2IconComponent, NavigationIconComponent, NetlifyIconComponent, NewspaperIconComponent, NodejsIconComponent, NotionIconComponent, NpmIconComponent, NumberInputComponent, OctagonIconComponent, PackageIconComponent, PaginatorComponent, PaletteIconComponent, PaperclipIconComponent, PauseCircleIconComponent, PauseIconComponent, PaypalIconComponent, PenToolIconComponent, PentagonIconComponent, PercentIconComponent, PhoneCallIconComponent, PhoneForwardedIconComponent, PhoneIconComponent, PhoneIncomingIconComponent, PhoneMissedIconComponent, PhoneOffIconComponent, PhoneOutgoingIconComponent, PictureInPictureIconComponent, PieChartIconComponent, PinIconComponent, PinterestIconComponent, PlayCircleIconComponent, PlayIconComponent, PlaylistIconComponent, PlugIconComponent, PlusCircleIconComponent, PlusIconComponent, PlusSquareIconComponent, PocketIconComponent, PopoverComponent, PowerIconComponent, PrinterIconComponent, ProgressBarComponent, PythonIconComponent, QrCodeIconComponent, QuestionExclamationMarkIconComponent, QuestionMarkIconComponent, RadioComponent, RadioGroupComponent, RadioIconComponent, RangeSliderComponent, RatingComponent, ReactIconComponent, ReceiptIconComponent, RecordIconComponent, RectangleHorizontalIconComponent, RectangleVerticalIconComponent, RedditIconComponent, RedoIconComponent, RefreshCcwIconComponent, RefreshCwIconComponent, RepeatIconComponent, RewindIconComponent, RightHalfStarIconComponent, RocketIconComponent, RotateCcwIconComponent, RotateCcwSquareIconComponent, RotateCwIconComponent, RowsIconComponent, RssIconComponent, SaveIconComponent, ScanIconComponent, ScissorsIconComponent, SearchIconComponent, SecondPlaceMedalIconComponent, SegmentedComponent, SendIconComponent, ServerIconComponent, SettingsIconComponent, ShareIconComponent, ShieldCheckIconComponent, ShieldIconComponent, ShieldOffIconComponent, ShopifyIconComponent, ShoppingBagIconComponent, ShoppingCartIconComponent, ShuffleIconComponent, SidebarIconComponent, SkeletonComponent, SkipBackIconComponent, SkipForwardIconComponent, Slack2IconComponent, SlackIconComponent, SlashIconComponent, SliderComponent, SlidersIconComponent, SmartphoneIconComponent, SmileIconComponent, SnowflakeIconComponent, SoccerBallIconComponent, SparklesIconComponent, SpeakerIconComponent, SpinnerComponent, SpotifyIconComponent, SquareIconComponent, StarIconComponent, StepComponent, StepperComponent, StopCircleIconComponent, StripeIconComponent, SubtitlesIconComponent, SunIconComponent, SunriseIconComponent, SunsetIconComponent, SvelteIconComponent, SwitchComponent, TabComponent, TableIconComponent, TabletIconComponent, TabsComponent, TagComponent, TagIconComponent, TailwindIconComponent, TargetIconComponent, TelegramIconComponent, TerminalIconComponent, TextareaComponent, ThermometerIconComponent, ThirdPlaceMedalIconComponent, ThreadsIconComponent, ThumbsDownIconComponent, ThumbsUpIconComponent, TiktokIconComponent, TimePickerComponent, TimecodeIconComponent, TimelineComponent, TimerIconComponent, ToastComponent, ToastService, ToggleLeftIconComponent, ToggleRightIconComponent, ToolIconComponent, TooltipDirective, TranscodeIconComponent, TransferListComponent, Trash2IconComponent, TrashIconComponent, TreeComponent, TrelloIconComponent, TrendingDownIconComponent, TrendingUpIconComponent, TriangleIconComponent, TrimIconComponent, TrophyIconComponent, TruckIconComponent, TvIconComponent, Twitch2IconComponent, TwitchIconComponent, TwitterIconComponent, TypeIconComponent, UmbrellaIconComponent, UnderlineIconComponent, UndoIconComponent, UnlockIconComponent, UploadCloudIconComponent, UploadIconComponent, UserCheckIconComponent, UserIconComponent, UserMinusIconComponent, UserPlusIconComponent, UserXIconComponent, UsersIconComponent, VercelIconComponent, VideoIconComponent, VideoOffIconComponent, VirtualListComponent, VoicemailIconComponent, Volume1IconComponent, Volume2IconComponent, VolumeIconComponent, VolumeXIconComponent, VueIconComponent, WCAG_AA, WalletIconComponent, WandIconComponent, WatchIconComponent, WaveformIconComponent, WhatsappIconComponent, WifiIconComponent, WifiOffIconComponent, WindIconComponent, WordpressIconComponent, XCircleIconComponent, XIconComponent, XOctagonIconComponent, XSquareIconComponent, XTwitterIconComponent, Youtube2IconComponent, YoutubeIconComponent, ZapIconComponent, ZapOffIconComponent, ZoomInIconComponent, ZoomOutIconComponent, applyPalette, ar, computePopoverPosition, contrastRatio, de, derivePalette, el, en, esES, formatViolations, frFR, frenchSpacing, he, hexToOklch, hi, iconDisplayName, is, isGrouped, nl, oklchToHex, pl, provideEagamiUi, ptBR, relativeLuminance, ru, uk, validatePalette, visibleNodeIds, walkTree, zhCN };
export type { AccordionHeadingLevel, AccordionSize, AlertSize, AlertVariant, AutocompleteSize, AvatarEditorCropEvent, AvatarEditorCropState, AvatarEditorShape, AvatarShape, AvatarSize, BadgeShape, BadgeSize, BadgeVariant, BreadcrumbClickEvent, BreadcrumbItem, BreadcrumbsSeparator, BreadcrumbsSize, ButtonSize, ButtonType, ButtonVariant, CardHeaderAlign, CardPadding, CardVariant, CheckboxSize, CodeInputSize, ColorPickerFormat, ColorPickerInputMode, ColorPickerSize, ColorPickerValue, CommandPaletteItem, ContrastSurfaces, ContrastViolation, DataTableColumn, DataTableDensity, DataTableSize, DataTableSortDirection, DataTableSortState, DatePickerFormat, DatePickerSize, DatePickerValue, DatePickerWeekStart, DerivedPalette, DialogWidth, DividerOrientation, DrawerAnimation, DrawerMode, DrawerPosition, DrawerSize, DropdownSize, EaErrorMessages, EaSize, EaValidationErrorKey, EaWidth, EagamiI18nConfig, EagamiLocale, EagamiLocaleBundle, EagamiLocaleLoader, EagamiLocaleMeta, EagamiMessages, EagamiMessagesOverride, EagamiPaletteConfig, EagamiUiConfig, EagamiWordmarkLayout, EagamiWordmarkVariant, EmptyStateHeadingLevel, EmptyStateSize, FileUploaderRejection, FileUploaderRejectionReason, FileUploaderSize, FormFieldSize, IconCategory, IconComponentType, IconMeta, InputSize, InputType, MenuItemVariant, MenuPlacement, MenuSize, ModePalette, ModeSurfaces, MultiSelectSize, NumberInputSize, PaginatorAlign, PaginatorSize, PaginatorState, PaletteConfig, PaletteRoles, PaletteShade, PopoverMaxWidth, PopoverPlacement, PopoverPositionOptions, PopoverPositionResult, PopoverRole, PopoverScrollBehavior, ProgressBarSize, ProgressBarVariant, RadioOrientation, RadioSize, RangeSliderSize, RangeSliderValue, RatingSize, RatingStarState, SegmentedSize, SelectOption, SelectOptionGroup, SelectOptions, SkeletonVariant, SliderSize, SpinnerSize, StepperOrientation, StepperSize, SwitchSize, TabsSize, TabsVariant, TagSize, TagTooltip, TagVariant, TextareaResize, TextareaSize, TimePickerFormat, TimePickerSize, TimelineAlign, TimelineItem, TimelineItemColor, TimelineOrientation, TimelineSize, Toast, ToastOptions, ToastPosition, ToastSegment, ToastSize, ToastText, ToastVariant, TooltipPosition, TransferListItem, TransferListSize, TreeNode, TreeSize, VirtualListItemContext };