@ngneers/controls 0.0.1-next.0

package/types/ngneers-controls-accordion.d.ts

@@ -0,0 +1,139 @@
+import * as _ngneers_controls_custom_types from '@ngneers/controls-custom-types';
+import * as _iconify_types from '@iconify/types';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, ElementRef } from '@angular/core';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { NgnBase } from '@ngneers/controls/base';
+
+/**
+ * @category control
+ */
+declare class NgnAccordion extends NgnBase<'accordion'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"accordion", ["root"], readonly []>>;
+    /**
+     * Whether to keep lazily-loaded panel content in the DOM after the panel closes.
+     * Applies as the default for every panel; individual panels can override it.
+     * @default false
+     */
+    readonly cache: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether to defer rendering each panel's content until it is first expanded.
+     * Applies as the default for every panel; individual panels can override it.
+     * @default false
+     */
+    readonly lazy: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Icon shown on a panel header when the panel is expanded.
+     */
+    readonly iconExpanded: _angular_core.InputSignal<_iconify_types.IconifyIcon | _ngneers_controls_custom_types.NgnIconEntry | undefined>;
+    /**
+     * Icon shown on a panel header when the panel is collapsed.
+     */
+    readonly iconCollapsed: _angular_core.InputSignal<_iconify_types.IconifyIcon | _ngneers_controls_custom_types.NgnIconEntry | undefined>;
+    /**
+     * Whether multiple panels can be expanded at once. When `false`, expanding a
+     * panel collapses any other open panel.
+     * @default false
+     */
+    readonly multiple: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The ids of the currently expanded panels. Two-way bindable to control or
+     * observe which panels are open.
+     * @default []
+     */
+    readonly expandedPanels: _angular_core.ModelSignal<string[]>;
+    togglePanel(panelId: string): void;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnAccordion, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnAccordion, "ngn-accordion", never, { "cache": { "alias": "cache"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "iconExpanded": { "alias": "iconExpanded"; "required": false; "isSignal": true; }; "iconCollapsed": { "alias": "iconCollapsed"; "required": false; "isSignal": true; }; "multiple": { "alias": "multiple"; "required": false; "isSignal": true; }; "expandedPanels": { "alias": "expandedPanels"; "required": false; "isSignal": true; }; }, { "expandedPanels": "expandedPanelsChange"; }, never, ["*"], true, never>;
+}
+
+type HeaderTemplateType = {
+    $implicit: {
+        panelId: string;
+        text?: string;
+        expanded: boolean;
+    };
+};
+
+declare abstract class AccordionTemplates extends NgnBase<'accordionPanel'> {
+    private readonly _defaultHeaderTemplate;
+    private readonly _userHeaderTemplate;
+    /**
+     * Set a custom template for the header of the accordion panel.
+     * Can also be set using an `<ng-template>` element with `#header` template reference variable.
+     */
+    readonly templateHeader: _angular_core.InputSignal<TemplateRef<HeaderTemplateType> | null>;
+    protected readonly headerTemplate: _angular_core.Signal<TemplateRef<HeaderTemplateType>>;
+    private readonly _userContentTemplate;
+    /**
+     * The required template for the content of the accordion panel.
+     * Can also be set using an `<ng-template>` element with `#content` template reference variable.
+     */
+    readonly templateContent: _angular_core.InputSignal<TemplateRef<unknown> | null>;
+    protected readonly contentTemplate: _angular_core.Signal<TemplateRef<unknown> | null>;
+    /**
+     * Types for the dialog templates.
+     */
+    readonly templateTypes: {
+        header: HeaderTemplateType;
+    } & {
+        $implicit: {
+            header: Partial<HeaderTemplateType>;
+        };
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AccordionTemplates, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<AccordionTemplates, never, never, { "templateHeader": { "alias": "templateHeader"; "required": false; "isSignal": true; }; "templateContent": { "alias": "templateContent"; "required": false; "isSignal": true; }; }, {}, ["_userHeaderTemplate", "_userContentTemplate"], never, true, never>;
+}
+
+/**
+ * @category control
+ */
+declare class NgnAccordionPanel extends AccordionTemplates {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"accordion-panel", ["root", "header", "header-disabled", "header-text", "content-expander", "content-expander-collapsed", "content"], readonly []>>;
+    private readonly _accordionControl;
+    /**
+     * The unique identifier for the accordion panel.
+     * @default generateElementId()
+     */
+    readonly panelId: _angular_core.InputSignal<string>;
+    /**
+     * Whether to lazily load the content of the panel when expanded.
+     * @default false
+     */
+    readonly lazy: _angular_core.InputSignalWithTransform<boolean | null, unknown>;
+    /**
+     * Whether to cache the content of the panel when {@link lazy} is enabled and the panel is closed.
+     * @default false
+     */
+    readonly cache: _angular_core.InputSignalWithTransform<boolean | null, unknown>;
+    /**
+     * The header text for the accordion panel.
+     */
+    readonly header: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the accordion panel is disabled. Disabling will prevent user interaction,
+     * but not automatically close the panel if it was already expanded, or is expanded programatically.
+     * @default false
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly iconExpanded: _angular_core.Signal<_iconify_types.IconifyIcon | _ngneers_controls_custom_types.NgnIconEntry>;
+    protected readonly iconCollapsed: _angular_core.Signal<_iconify_types.IconifyIcon | _ngneers_controls_custom_types.NgnIconEntry>;
+    protected readonly _contentViewChild: _angular_core.Signal<ElementRef<HTMLElement>>;
+    protected readonly expanded: _angular_core.Signal<boolean>;
+    protected readonly headerId: _angular_core.Signal<string>;
+    protected readonly contentId: _angular_core.Signal<string>;
+    protected readonly afterTransitionExpanded: _angular_core.WritableSignal<boolean>;
+    protected readonly lazyInt: _angular_core.Signal<boolean>;
+    protected readonly cacheInt: _angular_core.Signal<boolean>;
+    constructor();
+    /**
+     * Toggles the expanded state of the accordion panel.
+     */
+    toggle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnAccordionPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnAccordionPanel, "ngn-accordion-panel", never, { "panelId": { "alias": "panelId"; "required": false; "isSignal": true; }; "lazy": { "alias": "lazy"; "required": false; "isSignal": true; }; "cache": { "alias": "cache"; "required": false; "isSignal": true; }; "header": { "alias": "header"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { NgnAccordion, NgnAccordionPanel };

package/types/ngneers-controls-api-ng.d.ts

@@ -0,0 +1,364 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, Provider, ModelSignal, OutputEmitterRef, Signal, EnvironmentProviders, ComponentRef, InputSignal, InputSignalWithTransform, Injector, ElementRef, OnDestroy } from '@angular/core';
+import { Translations } from '@ngneers/controls/i18n';
+import { TimeSpan, LogLevel, DeepPartial } from '@ngneers/controls/utils';
+import { Placement, Strategy, Middleware, ComputePositionReturn, Side, Alignment } from '@floating-ui/dom';
+import { NgnStateStorage } from '@ngneers/controls/utils-ng';
+import { Theme, StyleScope, ControlName, ThemeClasses, ThemeTemplate, ControlTemplate } from '@ngneers/controls-themes';
+import { Observable } from 'rxjs';
+import { CustomColor, CustomKind } from '@ngneers/controls-custom-types';
+
+type TooltipOptions = {
+    /**
+     * The placement of the tooltip relative to the anchor element.
+     * @default bottom
+     */
+    readonly placement: Placement;
+    /**
+     * The offset in Pixels of the tooltip from the anchor element.
+     * @default 4
+     */
+    readonly offset: number;
+    /**
+     * The delay before the tooltip is shown. If a number is provided, it is interpreted as milliseconds.
+     * @default '0.5s'
+     */
+    readonly showDelay: TimeSpan;
+    /**
+     * The delay before the tooltip is hidden. If a number is provided, it is interpreted as milliseconds.
+     * @default '0.1s'
+     */
+    readonly hideDelay: TimeSpan;
+    /**
+     * Whether to show an arrow pointing to the anchor element. `""` is equivalent to `true`.
+     * @default true
+     */
+    readonly showArrow: boolean;
+    /**
+     * Shows the tooltip on hover.
+     * @default true
+     */
+    readonly showOnHover: boolean;
+    /**
+     * Shows the tooltip on focus.
+     * @default true
+     */
+    readonly showOnFocus: boolean;
+    /**
+     * Hides the tooltip (without delay) when the mouse hovers over the tooltip.
+     * @default false
+     */
+    readonly hideOnTooltipHover: boolean;
+    /**
+     * Hides the tooltip (without delay) when the user clicks on the tooltip.
+     * @default true
+     */
+    readonly hideOnClick: boolean;
+    /**
+     * Whether to automatically manage ARIA attributes for the tooltip.
+     * @default 'description'
+     */
+    readonly autoAriaMode: 'label' | 'description' | 'none';
+};
+
+declare const NGN_CONFIG: InjectionToken<NgnConfig>;
+type NgnConfig = {
+    readonly logLevel: LogLevel;
+    readonly customTranslations?: Record<string, () => Promise<Translations>>;
+    readonly disableAnimations: boolean;
+    readonly theme: {
+        readonly preset: Theme | null;
+        readonly lazyLoaded: boolean;
+        readonly styleScope: StyleScope | null;
+        readonly cssLayer: string | null;
+        readonly namePrefix: string;
+    };
+    readonly defaults: {
+        readonly stateStorage: NgnStateStorage;
+        readonly splitter: {
+            readonly stateStorage: NgnStateStorage;
+        };
+        readonly tooltip: TooltipOptions;
+    };
+};
+type NgnConfigInit = DeepPartial<NgnConfig, 'theme.preset.*' | 'theme.styleScope.*' | 'customTranslations.*'>;
+declare const defaultNgnConfig: NgnConfig;
+declare function provideNgnConfig(config?: NgnConfigInit): Provider;
+
+type PopoverCloseBy = 'any' | 'none';
+type CloseBy = PopoverCloseBy | 'escape';
+declare function toPopoverCloseBy(closeBy: CloseBy): 'auto' | 'manual';
+declare function toModalCloseBy(closeBy: CloseBy): 'any' | 'closerequest' | 'none';
+interface Openable {
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    open: ModelSignal<boolean>;
+    closed: OutputEmitterRef<void>;
+}
+
+type ColorScheme = 'light' | 'dark' | 'system';
+/** Storage key shared by ColorSchemeService and colorSchemeInitScript. */
+declare const COLOR_SCHEME_STORAGE_KEY = "ngn-color-scheme";
+/** Synchronous storage for the color-scheme preference (raw enum string, not JSON). */
+interface ColorSchemeStorage {
+    get(): ColorScheme | null;
+    set(value: ColorScheme): void;
+}
+declare const COLOR_SCHEME_STORAGE: InjectionToken<ColorSchemeStorage>;
+/** All valid {@link ColorScheme} values; used to validate values read from storage. */
+declare const COLOR_SCHEME_VALUES: readonly ColorScheme[];
+declare class ColorSchemeService {
+    private readonly _platform;
+    private readonly _storage;
+    private readonly _preference;
+    readonly preference: Signal<ColorScheme>;
+    readonly resolved: Signal<'light' | 'dark'>;
+    readonly isDark: Signal<boolean>;
+    constructor();
+    set(pref: ColorScheme): void;
+    cycle(): void;
+    private readInitial;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColorSchemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColorSchemeService>;
+}
+
+type NgnFeature = {
+    providers: (Provider | EnvironmentProviders)[];
+};
+declare function provideNgnControls(config?: NgnConfigInit, ...features: NgnFeature[]): (Provider | EnvironmentProviders)[];
+
+type ColorSchemeStorageOption = 'local' | 'session' | ColorSchemeStorage;
+declare function colorSchemeInitScript(options?: {
+    storage?: 'local' | 'session';
+}): string;
+declare function withAutoColorScheme(options?: {
+    storage?: ColorSchemeStorageOption;
+}): NgnFeature;
+
+type ComponentFromRef<T extends ComponentRef<any>> = T extends ComponentRef<infer C> ? C : never;
+type InputsFromComponent<T> = {
+    [K in keyof T]: T[K] extends InputSignal<infer V> ? V : T[K] extends InputSignalWithTransform<infer V, infer _> ? V : never;
+};
+declare function setComponentInput<T extends ComponentRef<C>, C, Input extends InputsFromComponent<ComponentFromRef<T>>, I extends keyof Input & string>(componentRef: T, inputName: I, value: Input[I]): void;
+
+type Size = {
+    width: number;
+    height: number;
+};
+type ElementArray = Signal<ReadonlyArray<HTMLElement | ElementRef<HTMLElement>>> | ReadonlyArray<HTMLElement | ElementRef<HTMLElement>>;
+type ElementSingle = Signal<HTMLElement | ElementRef<HTMLElement> | undefined> | HTMLElement | Document | ElementRef<HTMLElement>;
+declare function elementSizeSignal(element: ElementSingle, active?: Signal<boolean>): Signal<Size>;
+declare function elementsSizesSignal(element: ElementArray, active?: Signal<boolean>): Signal<readonly Size[]>;
+/**
+ * @todo use dom event functions directly and remove this function
+ * @deprecated use dom event functions instead
+ */
+declare function abortSignalOnDestroy(options?: {
+    injector?: Injector;
+}): AbortSignal;
+/**
+ * Creates an Observable that emits the latest event of the specified type from the given DOM element.
+ *
+ * ⚠️ Cannot be used to cancel or call preventDefault on the event, as the event is emitted after the event handler phase.
+ * @param element The target DOM element or ElementRef. Either can be provided directly or via a Signal.
+ * @param eventName The name of the event to listen for.
+ * @param injector Optional injector to use for lifecycle management. If not provided, the current injector is used.
+ * @returns An Observable that emits the latest event of the specified type. Does not complete until the injector is destroyed.
+ */
+declare function domEventObservable<EventName extends keyof GlobalEventHandlersEventMap>(element: ElementSingle, eventName: EventName, injector?: Injector): Observable<GlobalEventHandlersEventMap[EventName]>;
+/**
+ * Creates a Signal that emits the latest event of the specified type from the given DOM element.
+ *
+ * ⚠️ Cannot be used to cancel or call preventDefault on the event, as the event is emitted after the event handler phase.
+ * @param element The target DOM element or ElementRef. Either can be provided directly or via a Signal.
+ * @param eventName The name of the event to listen for.
+ * @param injector Optional injector to use for lifecycle management. If not provided, the current injector is used.
+ * @returns A Signal that emits the latest event of the specified type or null if no event has occurred.
+ */
+declare function domEventSignal<EventName extends keyof GlobalEventHandlersEventMap>(element: ElementSingle, eventName: EventName, injector?: Injector): Signal<GlobalEventHandlersEventMap[EventName] | null>;
+/**
+ * Attaches an event handler to a DOM element that is automatically removed when the injector is destroyed.
+ * @param element The target DOM element or ElementRef. Either can be provided directly or via a Signal.
+ * @param eventName The name of the event to listen for.
+ * @param handler The function to handle the event.
+ * @param injector Optional injector to use for lifecycle management. If not provided, the current injector is used.
+ * @param options Optional addEventListener options (e.g. `{ capture: true }`).
+ */
+declare function domEventHandler<EventName extends keyof GlobalEventHandlersEventMap>(element: ElementSingle, eventName: EventName, handler: (event: GlobalEventHandlersEventMap[EventName]) => void, injector?: Injector, options?: AddEventListenerOptions): void;
+
+/**
+ * Retrieves the available kinds for a given control from the active theme, as a reactive signal
+ * that updates when the active theme changes. Does **not** return custom kinds defined by the
+ * user in `NgnCustomTypes`.
+ * @param controlName The name of the control to get kinds for.
+ * @returns A signal of the available kinds for the specified control.
+ */
+declare function injectThemeControlKinds<T extends string>(controlName: T): Signal<CustomKind<T>[]>;
+/**
+ * Retrieves the available colors from the active theme, as a reactive signal that updates when
+ * the active theme changes. Does **not** return custom colors defined by the user in
+ * `NgnCustomTypes`.
+ * @returns A signal of the available colors.
+ */
+declare function injectThemeColors(controlName?: string): Signal<CustomColor[]>;
+
+type DeviceType = 'mobile' | 'desktop' | 'tablet';
+declare class Platform {
+    private readonly _deviceType;
+    private readonly _prefersColorScheme;
+    readonly isBrowser: boolean;
+    readonly windowSize: Signal<Size>;
+    readonly width: Signal<number>;
+    readonly height: Signal<number>;
+    readonly prefersColorScheme: Signal<'light' | 'dark'>;
+    constructor();
+    readonly isTouchDevice: Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Platform, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Platform>;
+}
+
+type Point = {
+    x: number;
+    y: number;
+};
+type Anchor = HTMLElement | Point;
+type PositioningSizeConstraints = {
+    /**
+     * The minimum width of the floating element. When a string is provided, it is used as the CSS min-width value.
+     */
+    minWidth?: string;
+    /**
+     * The width of the floating element. When a number is provided, it is relative to the width of the reference element.
+     * When a string is provided, it is used as the CSS width value.
+     */
+    width?: number | string;
+    /**
+     * The maximum width of the floating element. When a number is provided, it is relative to the width of the reference element.
+     * When a string is provided, it is used as the CSS max-width value.
+     */
+    maxWidth?: number | string;
+    /**
+     * The height of the floating element. When a string is provided, it is used as the CSS height value.
+     */
+    height?: string;
+    /**
+     * The maximum height of the floating element. When a string is provided, it is used as the CSS max-height value.
+     */
+    maxHeight?: string;
+    /**
+     * The minimum height of the floating element. When a string is provided, it is used as the CSS min-height value.
+     */
+    minHeight?: string;
+};
+type PositioningOptions = {
+    injector?: Injector;
+    placement?: Placement;
+    flip?: boolean;
+    resize?: boolean;
+    shift?: boolean;
+    offset?: number;
+    stopped?: boolean;
+    sizeConstraints?: PositioningSizeConstraints;
+    strategy?: Strategy;
+    middleware?: Middleware[];
+    disableSettingStyles?: boolean;
+    hasShrinkableContent?: boolean;
+    onPositionChange?: (position: ComputePositionReturn) => void;
+};
+type AutoPositioningHandle = {
+    stop: () => void;
+    start: () => void;
+    isRunning: () => boolean;
+};
+/**
+ * Snap a coordinate to the device-pixel grid. floating-ui returns subpixel
+ * coordinates; setting them raw puts the floating element (and its arrow) on
+ * fractional boundaries, producing blurry, non-deterministic anti-aliasing.
+ * Rounding by DPR keeps rendering crisp and stable. Matches floating-ui's own
+ * `roundByDPR` guidance.
+ */
+declare function roundByDpr(el: HTMLElement, value: number): number;
+declare function positionElement(anchor: Anchor, floatingEl: HTMLElement, options?: PositioningOptions): void;
+declare function autoPositionElement(anchor: Anchor, floatingEl: HTMLElement, options?: PositioningOptions): AutoPositioningHandle;
+declare function splitPlacement(placement: Placement): [Side, Alignment | undefined];
+
+type NgnStorageKind<T> = 'localstorage' | 'sessionstorage' | 'cookie' | {
+    initialize: () => T;
+    update: (value: T) => void;
+};
+declare class NgnStorage<T extends Record<string, unknown>> {
+    private readonly _store;
+    private readonly _set;
+    set<K extends keyof T>(key: K, value: T[K]): void;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    /**
+     * NOTE: must be constructed within an injection context — the built-in kinds
+     * read the platform (`PLATFORM_ID`) to stay SSR-safe, and the `cookie` kind
+     * additionally reads `DOCUMENT` / the SSR `REQUEST`.
+     */
+    constructor(key: string, kind: NgnStorageKind<T>, initialValue: T);
+    /** Parse persisted JSON, falling back to the caller's initial value. */
+    private _parse;
+}
+
+declare class NgnTemplate<T> {
+    readonly ngnTemplate: i0.InputSignal<T>;
+    static ngTemplateContextGuard<T>(dir: NgnTemplate<T>, ctx: unknown): ctx is T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgnTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgnTemplate<any>, "ng-template[ngnTemplate]", never, { "ngnTemplate": { "alias": "ngnTemplate"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * A noop with return type T.
+ * This function is used to define typed properties to use in a template.
+ */
+declare function templateTypesFn<T extends Record<string, Record<string, any>>>(): T & {
+    $implicit: { [K in keyof T]: Partial<T[K]>; };
+};
+/**
+ * A noop with return type `{ $implicit: Implicit } & Named`.
+ * This function is used to define a typed property to use in a template.
+ */
+declare function templateTypeFn<Implicit, Named extends Record<string, any> = object>(): ([Implicit] extends [undefined] ? unknown : {
+    $implicit: Implicit;
+}) & Named;
+
+type AppliedThemeClassCfg<T extends ControlName> = keyof ThemeClasses<ThemeTemplate[T]> | Partial<Record<keyof ThemeClasses<ThemeTemplate[T]>, boolean | (() => boolean)>>;
+type ControlTemplateInfo<T extends ControlTemplate<string, string[]>> = {
+    scope: string;
+    class: (className: T['classNames'][number]) => string;
+    classes: (classes: {
+        [K in T['classNames'][number]]?: boolean;
+    }) => string;
+};
+declare function themeTemplateToTemplateInfo<T extends ControlTemplate<string, string[]>>(config: NgnConfig, template: T, options?: {
+    unstyled?: () => boolean;
+}): ControlTemplateInfo<T>;
+declare function injectThemeTemplate<T extends ControlTemplate<string, string[]>>(template: T, options?: {
+    injector?: Injector;
+    unstyled?: () => boolean;
+}): ControlTemplateInfo<T>;
+declare function injectTheme<T extends ControlName>(controlName: T, options?: {
+    injector?: Injector;
+}): ControlTemplate<T, string[]>;
+declare function getAppliedClasses<T extends ControlName>(klass: AppliedThemeClassCfg<T>, themeTemplateInfo: Omit<ControlTemplateInfo<ControlTemplate<T, string[]>>, 'class' | 'classes'>): Array<{
+    class: string;
+    name: string;
+}>;
+declare class ThemeService implements OnDestroy {
+    private readonly _config;
+    private readonly _loadedScopes;
+    private readonly _document;
+    readonly activeTheme: i0.WritableSignal<Theme | null>;
+    constructor();
+    loadScope(scope: string): void;
+    ngOnDestroy(): void;
+    private onThemeChange;
+    private unloadAllScopes;
+    private applyTheme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+export { COLOR_SCHEME_STORAGE, COLOR_SCHEME_STORAGE_KEY, COLOR_SCHEME_VALUES, ColorSchemeService, NGN_CONFIG, NgnStorage, NgnTemplate, Platform, ThemeService, abortSignalOnDestroy, autoPositionElement, colorSchemeInitScript, defaultNgnConfig, domEventHandler, domEventObservable, domEventSignal, elementSizeSignal, elementsSizesSignal, getAppliedClasses, injectTheme, injectThemeColors, injectThemeControlKinds, injectThemeTemplate, positionElement, provideNgnConfig, provideNgnControls, roundByDpr, setComponentInput, splitPlacement, templateTypeFn, templateTypesFn, themeTemplateToTemplateInfo, toModalCloseBy, toPopoverCloseBy, withAutoColorScheme };
+export type { Anchor, AppliedThemeClassCfg, AutoPositioningHandle, CloseBy, ColorScheme, ColorSchemeStorage, ColorSchemeStorageOption, ControlTemplateInfo, DeviceType, NgnConfig, NgnConfigInit, NgnFeature, NgnStorageKind, Openable, Point, PopoverCloseBy, PositioningOptions, PositioningSizeConstraints, Size, TooltipOptions };