@ngneers/controls 0.0.1-pre1 → 0.0.1-pre2

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

@@ -0,0 +1,53 @@
+import * as _angular_core from '@angular/core';
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { ValueControlBase } from '@ngneers/controls/base';
+import { NgnDragInfo } from '@ngneers/controls/directives';
+
+/**
+ * @category control
+ */
+declare class NgnSlider extends ValueControlBase<'slider', number> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"slider", ["root", "horizontal", "vertical", "track", "thumb", "fill", "invalid"], readonly _ngneers_controls_themes.ControlTemplate<string, string[], readonly any[]>[]>>;
+    private readonly _track;
+    /**
+     * The minimum value of the slider.
+     */
+    readonly min: _angular_core.InputSignal<number>;
+    /**
+     * Whether the slider is vertical.
+     */
+    readonly vertical: _angular_core.InputSignal<boolean>;
+    /**
+     * The maximum value of the slider.
+     */
+    readonly max: _angular_core.InputSignal<number>;
+    /**
+     * The step increment value.
+     */
+    readonly step: _angular_core.InputSignal<number>;
+    /**
+     * The value text representation for accessibility.
+     * If both {@link valueText} and {@link valueTextFn} are provided, {@link valueText} takes precedence.
+     */
+    readonly valueText: _angular_core.InputSignal<string | undefined>;
+    /**
+     * A function that generates the value text representation for accessibility.
+     * If both {@link valueText} and {@link valueTextFn} are provided, {@link valueText} takes precedence.
+     */
+    readonly valueTextFn: _angular_core.InputSignal<((value: number) => string) | undefined>;
+    protected readonly left: _angular_core.Signal<number>;
+    constructor();
+    protected readonly valueTextValue: _angular_core.Signal<string | null>;
+    protected onDragged(delta: NgnDragInfo): void;
+    private dragToPosition;
+    private clampValue;
+    protected onDragEnd(): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected thumbClicked(event: PointerEvent): void;
+    protected trackClicked(event: PointerEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnSlider, "ngn-slider", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "valueText": { "alias": "valueText"; "required": false; "isSignal": true; }; "valueTextFn": { "alias": "valueTextFn"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgnSlider };

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

@@ -0,0 +1,105 @@
+import * as _angular_core from '@angular/core';
+import { Injector, ElementRef, Signal } from '@angular/core';
+import { CustomColor } from '@ngneers/controls-custom-types';
+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';
+
+/**
+ * Creates an instance of the spinner creator.
+ *
+ * @param injector The injector to use. Defaults to the current injector.
+ * @returns The spinner creator.
+ */
+declare function injectSpinnerCreator(injector?: Injector): NgnSpinnerCreator;
+/**
+ * Creates and manages a conditional spinner based on a visibility signal.
+ * @param isVisible Signal that determines whether the spinner is visible.
+ * @param options Optional configuration for the spinner.
+ */
+declare function createConditionalSpinner(isVisible: Signal<boolean>, options?: {
+    /**
+     * Options for the spinner instance.
+     */
+    spinnerOptions?: SpinnerOptions;
+    /**
+     * Debounce time in milliseconds or a boolean indicating whether to debounce (default is 200ms).
+     */
+    debounce?: number | boolean;
+    /**
+     * The target element where the spinner will be attached.
+     * If a string is provided, it will be used as a selector to find the element.
+     * If omitted, the spinner will be attached to the host element of the current injector.
+     */
+    element?: SpinnerTarget;
+    /**
+     * The injector to use. If omitted, the current injector will be used.
+     */
+    injector?: Injector;
+}): void;
+type SpinnerRef = {
+    /**
+     * Hides the spinner.
+     */
+    hide: () => void;
+};
+type SpinnerTarget = HTMLElement | ElementRef<HTMLElement> | string;
+type SpinnerOptions = {
+    /**
+     * The color of the spinner.
+     */
+    color?: CustomColor;
+    /**
+     * The diameter of the spinner in pixels.
+     * @default 64
+     */
+    size?: number;
+    /**
+     * The thickness of the spinner's stroke. If not provided,
+     * a default thickness derived from the size will be used.
+     * @default undefined
+     */
+    thickness?: string;
+    /**
+     * Whether the spinner should be centered within its container.
+     * @default true
+     */
+    centered?: boolean;
+    /**
+     * Set aria busy attribute on the reference element while the spinner is visible.
+     * @default true
+     */
+    ariaBusy?: boolean;
+};
+declare class NgnSpinnerCreator {
+    private readonly _vcr;
+    private readonly _destroyRef;
+    private _destroyed;
+    constructor();
+    /**
+     * Shows a spinner on the specified target element.
+     * @param target The target element or selector where the spinner will be attached.
+     * If a string is provided, it will be used as a selector to find the element.
+     * If the element is not found, the spinner will be retried until it is found.
+     * @param options Optional configuration for the spinner.
+     * @returns A reference to the spinner instance.
+     */
+    show(target: SpinnerTarget, options?: SpinnerOptions): SpinnerRef;
+    private _tryAttach;
+}
+
+/**
+ * @category control
+ */
+declare class NgnSpinner extends NgnBase<'spinner'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"spinner", ["root", "circle", "svg", `color-${string}`, "centered"], readonly _ngneers_controls_themes.ControlTemplate<string, string[], readonly any[]>[]>>;
+    readonly size: _angular_core.InputSignal<number>;
+    readonly thickness: _angular_core.InputSignal<string | undefined>;
+    readonly centered: _angular_core.InputSignal<boolean | undefined>;
+    protected readonly viewBox: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnSpinner, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnSpinner, "ngn-spinner", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "thickness": { "alias": "thickness"; "required": false; "isSignal": true; }; "centered": { "alias": "centered"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgnSpinner, createConditionalSpinner, injectSpinnerCreator };
+export type { SpinnerOptions, SpinnerRef, SpinnerTarget };

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

@@ -0,0 +1,391 @@
+import * as _angular_core from '@angular/core';
+import { Signal, EmbeddedViewRef, OnDestroy } from '@angular/core';
+import * as _ngneers_controls_splitter from '@ngneers/controls/splitter';
+import * as _ngneers_signal_translate from '@ngneers/signal-translate';
+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';
+import { NgnStateStorage } from '@ngneers/controls/utils-ng';
+
+/**
+ * @category control
+ */
+declare class NgnSplitterPanel extends NgnBase<'splitter'> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"splitter", ["root", "horizontal", "vertical", "panel", "divider", "divider-handle", "dragging", "divider-dragging"], readonly _ngneers_controls_themes.ControlTemplate<string, string[], readonly any[]>[]>>;
+    private readonly _fallbackAreaName;
+    readonly name: _angular_core.InputSignal<string | null | undefined>;
+    readonly size: _angular_core.ModelSignal<`${number}px` | `${number}fr`>;
+    readonly minSize: _angular_core.ModelSignal<`${number}px` | `${number}%`>;
+    readonly maxSize: _angular_core.ModelSignal<`${number}px` | `${number}%`>;
+    readonly ariaLabel: _angular_core.InputSignal<string | null | undefined>;
+    readonly ariaLabelledBy: _angular_core.InputSignal<string | null | undefined>;
+    protected readonly gridArea: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnSplitterPanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnSplitterPanel, "ngn-splitter-panel", never, { "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "minSize": { "alias": "minSize"; "required": false; "isSignal": true; }; "maxSize": { "alias": "maxSize"; "required": false; "isSignal": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; "isSignal": true; }; "ariaLabelledBy": { "alias": "ariaLabelledBy"; "required": false; "isSignal": true; }; }, { "size": "sizeChange"; "minSize": "minSizeChange"; "maxSize": "maxSizeChange"; }, never, ["*"], true, never>;
+}
+
+type SplitterPanelSizeUnit = 'px' | 'fr';
+type SplitterPanelSize<U extends SplitterPanelSizeUnit = SplitterPanelSizeUnit> = `${number}${U}`;
+type SplitterPanelSizeLimitUnit = 'px' | '%';
+type SplitterPanelSizeLimit<U extends SplitterPanelSizeLimitUnit = SplitterPanelSizeLimitUnit> = `${number}${U}`;
+type SplitterLayout = 'horizontal' | 'vertical';
+type _SplitterState = {
+    layout?: SplitterLayout;
+    panelOrder?: string[] | null;
+    panelSizes?: Record<string, SplitterPanelSize> | null;
+};
+type SplitterStateData = keyof _SplitterState;
+type SplitterState = _SplitterState & {
+    [key: string]: unknown;
+};
+
+type ExpandedSplitterPanelSize = {
+    value: number;
+    unit: SplitterPanelSizeUnit;
+};
+type ExpandedSplitterPanelSizeLimit = {
+    value: number;
+    unit: SplitterPanelSizeLimitUnit;
+};
+
+/**
+ * Type interface for the {@link SplitterCalculator} interface.
+ */
+interface SplitterCalculatorType {
+    new (splitter: NgnSplitter): SplitterCalculator;
+}
+/**
+ * Represents a calculator for the {@link NgnSplitter} component, handling panel sizes, drag events, and min/max size constraints.
+ * This interface defines the methods and properties required for managing the splitter's layout and behavior.
+ */
+interface SplitterCalculator {
+    /**
+     * Signal that provides the ordered list of panels in the splitter.
+     */
+    orderedPanels: Signal<readonly NgnSplitterPanel[]>;
+    /**
+     * Signal that provides the grid template sizes for the splitter (to use in `grid-template-rows` or `grid-template-columns` CSS properties).
+     */
+    gridTemplateSizes: Signal<string>;
+    /**
+     * Signal that provides the grid template areas for the splitter (to use in `grid-template-areas` CSS property).
+     */
+    gridTemplateAreas: Signal<string | null>;
+    /**
+     * Signal that provides the current drag context. Returns `null` if no drag is in progress.
+     */
+    dragContext: Signal<SplitterDragContext | null>;
+    /**
+     * Signal that provides the minimum size of the splitter, calculated based on the panels' min sizes and dividers.
+     */
+    minSize: Signal<string>;
+    /**
+     * Signal that provides the maximum size of the splitter, calculated based on the panels' max sizes and dividers.
+     */
+    maxSize: Signal<string>;
+    /**
+     * Starts a drag operation for the specified divider index.
+     * @param index The index of the divider to start dragging.
+     * @param event The pointer event that initiated the drag.
+     */
+    startDrag(index: number, event: PointerEvent): void;
+    /**
+     * Handles the drag operation for the specified divider index.
+     * @param index The index of the divider being dragged.
+     * @param event The pointer event that is being processed during the drag.
+     */
+    drag(index: number, event: PointerEvent): void;
+    /**
+     * Ends the drag operation for the specified divider index.
+     * @param index The index of the divider being dragged.
+     * @param event The pointer event that ended the drag.
+     * @param isCancel Whether the drag operation was cancelled. If true, the panel sizes will be reset to their original values.
+     */
+    endDrag(index: number, event: PointerEvent, isCancel: boolean): void;
+    /**
+     * Moves the divider at the specified index by the given pixel delta.
+     * @param index The index of the divider to move.
+     * @param pxDelta The pixel delta to move the divider by. Positive values move the divider to the right (or down), negative values move it to the left (or up).
+     */
+    moveDivider(index: number, pxDelta: number): void;
+}
+type SplitterFractionFactors = {
+    /**
+     * The number of fraction units per pixel.
+     * This is used to convert pixel values to fraction values.
+     */
+    frPerPx: number;
+    /**
+     * The number of pixels per fraction unit.
+     * This is used to convert fraction values to pixel values.
+     */
+    pxPerFr: number;
+};
+type SplitterDragContextPanel = {
+    /**
+     * A reference to the panel component.
+     */
+    panel: NgnSplitterPanel;
+    /**
+     * The starting size of the panel at the beginning of the drag operation.
+     */
+    startSize: ExpandedSplitterPanelSize;
+    /**
+     * The minimum size limit of the panel.
+     */
+    minSize: ExpandedSplitterPanelSizeLimit;
+    /**
+     * The maximum size limit of the panel.
+     */
+    maxSize: ExpandedSplitterPanelSizeLimit;
+};
+/**
+ * Represents the context of a drag operation in the splitter.
+ */
+type SplitterDragContext = {
+    /**
+     * The index of the divider being dragged.
+     */
+    dividerIndex: number;
+    /**
+     * The ID of the pointer that initiated the drag operation.
+     */
+    pointerId: number;
+    /**
+     * The starting position of the pointer when the drag operation started, in pixels.
+     */
+    startPosition: number;
+    /**
+     * An array of panels involved in the drag operation.
+     */
+    panels: SplitterDragContextPanel[];
+    /**
+     * The fraction factors used for calculating sizes during the drag operation.
+     */
+    fractionFactors: SplitterFractionFactors;
+};
+/**
+ * Default implementation of the {@link SplitterCalculator} interface.
+ */
+declare class DefaultSplitterCalculator implements SplitterCalculator {
+    protected readonly panels: Signal<readonly NgnSplitterPanel[]>;
+    protected readonly dividers: Signal<readonly EmbeddedViewRef<unknown>[]>;
+    protected readonly panelOrder: Signal<readonly string[] | null | undefined>;
+    protected readonly layout: Signal<SplitterLayout>;
+    protected readonly splitterSize: Signal<number>;
+    constructor(splitter: NgnSplitter);
+    readonly orderedPanels: Signal<readonly NgnSplitterPanel[]>;
+    readonly gridTemplateSizes: Signal<string>;
+    readonly gridTemplateAreas: Signal<string | null>;
+    readonly minSize: Signal<string>;
+    readonly maxSize: Signal<string>;
+    readonly dragContext: _angular_core.WritableSignal<SplitterDragContext | null>;
+    protected readonly dividerSizes: Signal<number[]>;
+    protected readonly totalDividerSize: Signal<number>;
+    protected readonly totalPanelSizes: Signal<{
+        px: number;
+        fr: number;
+    }>;
+    startDrag(index: number, event: PointerEvent): void;
+    drag(index: number, event: PointerEvent): void;
+    endDrag(index: number, event: PointerEvent, isCancel: boolean): void;
+    moveDivider(index: number, pxDelta: number): void;
+    ensureMinMaxSizes(): void;
+    private createContextPanel;
+    private getCurrentFractionFactors;
+    private setPanelSize;
+    private isPanelSizeCalculated;
+    private applyDividerDelta;
+}
+
+/**
+ * @category control
+ */
+declare class NgnSplitter extends NgnBase<'splitter'> implements OnDestroy {
+    private readonly _viewContainer;
+    private readonly _config;
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"splitter", ["root", "horizontal", "vertical", "panel", "divider", "divider-handle", "dragging", "divider-dragging"], readonly _ngneers_controls_themes.ControlTemplate<string, string[], readonly any[]>[]>>;
+    protected readonly translations: _ngneers_signal_translate.TranslationsSignal<{
+        calendar: {
+            today: string;
+            selectYear: string;
+            weekdays: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            weekdaysShort: {
+                monday: string;
+                tuesday: string;
+                wednesday: string;
+                thursday: string;
+                friday: string;
+                saturday: string;
+                sunday: string;
+            };
+            months: {
+                january: string;
+                february: string;
+                march: string;
+                april: string;
+                may: string;
+                june: string;
+                july: string;
+                august: string;
+                september: string;
+                october: string;
+                november: string;
+                december: string;
+            };
+        };
+        editInplace: {
+            placeholder: string;
+        };
+        filter: {
+            noFilter: string;
+            addCondition: string;
+            removeCondition: string;
+            clear: string;
+            matchModeLabel: string;
+            match: {
+                all: string;
+                any: string;
+            };
+            selected: string;
+            conditions: string;
+            operators: {
+                isEqual: string;
+                isNotEqual: string;
+                contains: string;
+                startsWith: string;
+                endsWith: string;
+                in: string;
+                isEmpty: string;
+                isNotEmpty: string;
+                greaterThan: string;
+                greaterThanOrEqual: string;
+                lessThan: string;
+                lessThanOrEqual: string;
+                after: string;
+                onOrAfter: string;
+                before: string;
+                onOrBefore: string;
+                isTrue: string;
+                isFalse: string;
+                custom: string;
+            };
+        };
+        splitter: {
+            handleLabel: string;
+        };
+        inputField: {
+            clearInput: string;
+        };
+        drawer: {
+            close: string;
+        };
+    }, "_">;
+    /**
+     * The layout of the splitter.
+     */
+    readonly layout: _angular_core.ModelSignal<SplitterLayout>;
+    /**
+     * A array of panel names that defines the order of panels.
+     * If nullish, the order is determined by the order the panels are defined in the template.
+     */
+    readonly panelOrder: _angular_core.ModelSignal<string[] | null | undefined>;
+    /**
+     * The storage to use for saving the splitter state.
+     * @default `session`
+     */
+    readonly stateStorage: _angular_core.InputSignal<NgnStateStorage>;
+    /**
+     * The key to use for saving the splitter state.
+     * If nullish, the state will not be saved.
+     */
+    readonly stateKey: _angular_core.InputSignal<string | null | undefined>;
+    /**
+     * The type of data to save in the splitter state.
+     * @default `['layout', 'panelOrder', 'panelSizes']`
+     */
+    readonly stateData: _angular_core.InputSignal<readonly (keyof {
+        layout?: SplitterLayout;
+        panelOrder?: string[] | null;
+        panelSizes?: Record<string, _ngneers_controls_splitter.SplitterPanelSize> | null;
+    })[]>;
+    /**
+     * The type of calculator to use for the splitter.
+     * @default `DefaultSplitterCalculator`
+     */
+    readonly calculatorType: _angular_core.InputSignal<SplitterCalculatorType>;
+    /**
+     * The step size for moving the dividers using the keyboard.
+     * This can be a pixel value (e.g., '5px') or a percentage value (e.g., '5%').
+     * If a percentage is used, it will be calculated based on the size of the splitter element.
+     * @default '5px'
+     */
+    readonly step: _angular_core.InputSignal<`${number}px` | `${number}%`>;
+    /**
+     * Event emitted when the splitter state is being saved.
+     * This can be used to modify the state before it is saved.
+     */
+    readonly stateSaving: _angular_core.OutputEmitterRef<SplitterState>;
+    /**
+     * Event emitted when the splitter state is loaded.
+     * This can be used to modify the state before it is applied or to perform actions based on the loaded state.
+     */
+    readonly stateLoading: _angular_core.OutputEmitterRef<SplitterState>;
+    protected readonly dividerTemplateType: {
+        index: number;
+    };
+    private readonly _dividerTemplate;
+    /**
+     * The current dividers in the splitter.
+     */
+    readonly dividers: _angular_core.WritableSignal<EmbeddedViewRef<{
+        index: number;
+    }>[]>;
+    /**
+     * The current panels in the splitter.
+     */
+    readonly panels: _angular_core.Signal<readonly NgnSplitterPanel[]>;
+    /**
+     * The current size of the splitter element.
+     */
+    readonly elementSize: _angular_core.Signal<_ngneers_controls_api_ng.Size>;
+    /**
+     * A value indicating whether the splitter is currently being dragged.
+     */
+    readonly isDragging: _angular_core.Signal<boolean>;
+    protected readonly calculator: _angular_core.Signal<_ngneers_controls_splitter.SplitterCalculator>;
+    constructor();
+    ngOnDestroy(): void;
+    protected onHandlePointerDown(index: number, event: PointerEvent): void;
+    protected onHandlePointerMove(index: number, event: PointerEvent): void;
+    protected onHandlePointerUp(index: number, event: PointerEvent): void;
+    protected onHandlePointerCancel(index: number, event: PointerEvent): void;
+    protected onHandleKeyDown(index: number, event: KeyboardEvent): void;
+    private updateDividers;
+    private createDivider;
+    private moveDividerBefore;
+    private computeState;
+    private onStateLoad;
+    private ensureValidState;
+    private applyFromState;
+    private getStepInPx;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnSplitter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<NgnSplitter, "ngn-splitter", never, { "layout": { "alias": "layout"; "required": true; "isSignal": true; }; "panelOrder": { "alias": "panelOrder"; "required": false; "isSignal": true; }; "stateStorage": { "alias": "stateStorage"; "required": false; "isSignal": true; }; "stateKey": { "alias": "stateKey"; "required": false; "isSignal": true; }; "stateData": { "alias": "stateData"; "required": false; "isSignal": true; }; "calculatorType": { "alias": "calculatorType"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; }, { "layout": "layoutChange"; "panelOrder": "panelOrderChange"; "stateSaving": "stateSaving"; "stateLoading": "stateLoading"; }, ["panels"], ["*"], true, never>;
+}
+
+declare class NgnSplitterModule {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgnSplitterModule, never>;
+    static ɵmod: _angular_core.ɵɵNgModuleDeclaration<NgnSplitterModule, never, [typeof NgnSplitter, typeof NgnSplitterPanel], [typeof NgnSplitter, typeof NgnSplitterPanel]>;
+    static ɵinj: _angular_core.ɵɵInjectorDeclaration<NgnSplitterModule>;
+}
+
+export { DefaultSplitterCalculator, NgnSplitter, NgnSplitterModule, NgnSplitterPanel };
+export type { SplitterCalculator, SplitterCalculatorType, SplitterDragContext, SplitterLayout, SplitterPanelSize, SplitterPanelSizeLimit, SplitterPanelSizeLimitUnit, SplitterPanelSizeUnit, SplitterState, SplitterStateData };

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

@@ -0,0 +1,18 @@
+import * as _ngneers_controls_api_ng from '@ngneers/controls/api/ng';
+import * as _ngneers_controls_themes from '@ngneers/controls-themes';
+import { ValueControlBase } from '@ngneers/controls/base';
+import * as i0 from '@angular/core';
+
+/**
+ * @category control
+ */
+declare class NgnSwitch extends ValueControlBase<'switch', boolean> {
+    protected readonly theme: _ngneers_controls_api_ng.ControlTemplateInfo<_ngneers_controls_themes.ControlTemplate<"switch", ["root", "input", "track", "track-checked", "thumb", "invalid"], readonly _ngneers_controls_themes.ControlTemplate<string, string[], readonly any[]>[]>>;
+    protected changed(event: Event): void;
+    protected onClick(event: Event): void;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgnSwitch, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgnSwitch, "ngn-switch", never, {}, {}, never, never, true, never>;
+}
+
+export { NgnSwitch };