@liuk123/insui 0.0.1-alpha.1

package/index.d.ts

@@ -0,0 +1,2511 @@
+import * as i0 from '@angular/core';
+import { OnInit, TemplateRef, Type, ExistingProvider, OnDestroy, Injector, ChangeDetectorRef, AfterViewInit, ComponentRef, InjectionToken, FactoryProvider, Signal, OnChanges, DoCheck, SimpleChanges, EventEmitter, EmbeddedViewRef, QueryList, Provider, ProviderToken, NgZone, ViewContainerRef, InputSignal, PipeTransform, ValueProvider, DestroyRef, ElementRef, TrackByFunction } from '@angular/core';
+import { SafeResourceUrl, SafeValue, EventManagerPlugin } from '@angular/platform-browser';
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, OperatorFunction, Observer, MonoTypeOperatorFunction, SchedulerLike, Subject } from 'rxjs';
+import * as _liuk123_insui from '@liuk123/insui';
+import { Validator, AbstractControl, ValidationErrors, NgControl, ControlValueAccessor, FormControlStatus, FormControl } from '@angular/forms';
+
+declare class InsExpand implements OnInit {
+    protected readonly content: i0.Signal<TemplateRef<any>>;
+    protected readonly open: i0.WritableSignal<boolean>;
+    protected expanded: i0.WritableSignal<boolean>;
+    set expandedSetter(expanded: boolean);
+    ngOnInit(): void;
+    protected onTransitionEnd({ propertyName }: TransitionEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsExpand, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsExpand, "ins-expand", never, { "expandedSetter": { "alias": "expanded"; "required": false; }; }, {}, ["content"], ["*"], true, never>;
+}
+
+type InsInteractiveState = 'active' | 'disabled' | 'hover';
+
+declare class InsTransitioned {
+    private readonly el;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTransitioned, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTransitioned, "[insTransitioned]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsAppearance {
+    protected readonly nothing: undefined;
+    readonly insAppearance: i0.ModelSignal<(Record<never, never> & string) | "accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "glass" | "icon" | "info" | "negative" | "neutral" | "outline-destructive" | "outline-grayscale" | "outline" | "positive" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield">;
+    readonly insAppearanceState: i0.ModelSignal<InsInteractiveState>;
+    readonly insAppearanceFocus: i0.ModelSignal<boolean>;
+    readonly insAppearanceMode: i0.ModelSignal<string | readonly string[]>;
+    modes: i0.Signal<string | readonly string[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAppearance, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsAppearance, "[insAppearance]", never, { "insAppearance": { "alias": "insAppearance"; "required": false; "isSignal": true; }; "insAppearanceState": { "alias": "insAppearanceState"; "required": false; "isSignal": true; }; "insAppearanceFocus": { "alias": "insAppearanceFocus"; "required": false; "isSignal": true; }; "insAppearanceMode": { "alias": "insAppearanceMode"; "required": false; "isSignal": true; }; }, { "insAppearance": "insAppearanceChange"; "insAppearanceState": "insAppearanceStateChange"; "insAppearanceFocus": "insAppearanceFocusChange"; "insAppearanceMode": "insAppearanceModeChange"; }, never, never, true, [{ directive: typeof InsTransitioned; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsWithAppearance {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsWithAppearance, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsWithAppearance, never, never, {}, {}, never, never, true, [{ directive: typeof InsAppearance; inputs: { "insAppearance": "appearance"; "insAppearanceState": "insAppearanceState"; "insAppearanceFocus": "insAppearanceFocus"; }; outputs: {}; }]>;
+}
+
+type InsHandler<T, G> = (item: T) => G;
+type InsBooleanHandler<T> = InsHandler<T, boolean>;
+type InsStringHandler<T> = InsHandler<T, string>;
+type InsNumberHandler<T> = InsHandler<T, number>;
+
+/**
+ * Workaround for {@link insAvatar} to properly handle icon color in {@link insAppearance}
+ */
+type Icon = SafeResourceUrl | string | null | undefined;
+declare function insInjectIconResolver(): InsStringHandler<string>;
+declare class InsIcons {
+    protected readonly nothing: undefined;
+    resolver: InsStringHandler<string>;
+    iconStartSrc: i0.WritableSignal<Icon>;
+    iconEndSrc: i0.WritableSignal<string>;
+    set iconStart(value: string);
+    set iconEnd(value: string);
+    resolve(value?: string | null): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsIcons, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsIcons, never, never, { "iconStart": { "alias": "iconStart"; "required": false; }; "iconEnd": { "alias": "iconEnd"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsWithIcons {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsWithIcons, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsWithIcons, never, never, {}, {}, never, never, true, [{ directive: typeof InsIcons; inputs: { "iconStart": "iconStart"; "iconEnd": "iconEnd"; }; outputs: {}; }]>;
+}
+
+declare class InsButton {
+    private readonly options;
+    protected readonly nothing: undefined;
+    size: i0.WritableSignal<"s" | "m" | "l" | "xs">;
+    set sizeSetter(size: 'xs' | 's' | 'm' | 'l');
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsButton, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsButton, "a[insButton],button[insButton],a[insIconButton],button[insIconButton]", never, { "sizeSetter": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof InsWithIcons; inputs: {}; outputs: {}; }]>;
+}
+
+type InsPoint = Readonly<[x: number, y: number]>;
+
+declare abstract class InsAccessor {
+    abstract readonly type: string;
+}
+declare abstract class InsPositionAccessor extends InsAccessor {
+    abstract getPosition(rect: DOMRect, element?: HTMLElement): InsPoint;
+}
+declare abstract class InsRectAccessor extends InsAccessor {
+    abstract getClientRect(): DOMRect;
+}
+declare function insAsPositionAccessor(accessor: Type<InsPositionAccessor>): ExistingProvider;
+declare function insAsRectAccessor(accessor: Type<InsRectAccessor>): ExistingProvider;
+
+declare class InsActiveZone implements OnDestroy {
+    private readonly control;
+    private readonly active$;
+    private readonly zone;
+    private readonly el;
+    subActiveZones: readonly InsActiveZone[];
+    private readonly directParentActiveZone;
+    insActiveZoneParent: i0.WritableSignal<InsActiveZone>;
+    set insActiveZoneParentSetter(v: InsActiveZone | null);
+    readonly insActiveZoneChange: Observable<boolean>;
+    constructor();
+    ngOnDestroy(): void;
+    contains(node: Node): boolean;
+    private setZone;
+    private addSubActiveZone;
+    private removeSubActiveZone;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsActiveZone, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsActiveZone, "[insActiveZone]:not(ng-container), [insActiveZoneChange]:not(ng-container), [insActiveZoneParent]:not(ng-container)", ["insActiveZone"], { "insActiveZoneParentSetter": { "alias": "insActiveZoneParent"; "required": false; }; }, { "insActiveZoneChange": "insActiveZoneChange"; }, never, never, true, never>;
+}
+
+declare class PolymorpheusComponent<T> {
+    readonly component: Type<T>;
+    readonly i?: Injector;
+    constructor(component: Type<T>, i?: Injector);
+    createInjector<C>(injector: Injector, useValue?: C): Injector;
+}
+
+/**
+ * ng-template wrapper directive also stores {@link ChangeDetectorRef} to properly handle change detection.
+ */
+declare class PolymorpheusTemplate<C = any> {
+    readonly template: TemplateRef<C>;
+    private readonly cdr;
+    polymorpheus: C | '';
+    constructor(template?: TemplateRef<C>, cdr?: ChangeDetectorRef);
+    static ngTemplateContextGuard<T>(_dir: PolymorpheusTemplate<T>, _ctx: any): _ctx is T extends '' ? any : T;
+    check(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PolymorpheusTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PolymorpheusTemplate<any>, "ng-template[polymorpheus]", ["polymorpheus"], { "polymorpheus": { "alias": "polymorpheus"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Primitive types used as content by {@link PolymorpheusOutlet}
+ */
+type PolymorpheusPrimitive = SafeValue | number | string | null | undefined;
+
+/**
+ * All content types supported by {@link PolymorpheusOutlet}
+ */
+type PolymorpheusContent<C = any> = PolymorpheusComponent<unknown> | PolymorpheusPrimitive | PolymorpheusTemplate<Partial<C> | ''> | TemplateRef<Partial<C>>;
+
+interface InsPortalItem<C = any> {
+    readonly activeZone?: InsActiveZone | null;
+    readonly appearance?: string;
+    readonly component: PolymorpheusComponent<any>;
+    readonly content: PolymorpheusContent<C>;
+    readonly context?: C;
+}
+
+declare abstract class InsVehicle {
+    abstract readonly type: string;
+    abstract toggle(value: boolean): void;
+}
+declare function insAsVehicle(vehicle: Type<InsVehicle>): ExistingProvider;
+
+interface InsContext<T> {
+    $implicit: T;
+}
+
+declare abstract class InsDriver extends Observable<boolean> {
+    abstract readonly type: string;
+}
+declare function insAsDriver(driver: Type<InsDriver>): ExistingProvider;
+declare abstract class InsDriverDirective implements AfterViewInit {
+    abstract type: string;
+    private readonly destroyRef;
+    private readonly drivers;
+    private readonly vehicles;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDriverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDriverDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class InsDropdownDriver extends BehaviorSubject<boolean> implements InsDriver {
+    readonly type = "dropdown";
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownDriver, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsDropdownDriver>;
+}
+declare class InsDropdownDriverDirective extends InsDriverDirective {
+    readonly type = "dropdown";
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownDriverDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownDriverDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class InsDropdownPosition extends InsPositionAccessor {
+    private readonly options;
+    private readonly viewport;
+    readonly accessor: InsRectAccessor | null;
+    readonly type = "dropdown";
+    private previous?;
+    getPosition({ width, height }: DOMRect): InsPoint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownPosition, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownPosition, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class InsDropdownDirective implements OnDestroy, InsPortalItem, InsRectAccessor, InsVehicle {
+    private readonly cdr;
+    private readonly service;
+    readonly el: HTMLElement;
+    readonly type = "dropdown";
+    readonly component: PolymorpheusComponent<any>;
+    ref: i0.WritableSignal<ComponentRef<unknown>>;
+    content: i0.WritableSignal<PolymorpheusContent<InsContext<{
+        close: () => void;
+        data: any;
+    }>>>;
+    private readonly drivers;
+    set insDropdown(content: PolymorpheusContent<InsContext<{
+        close: () => void;
+        data: any;
+    }>>);
+    itemData: any;
+    position: string;
+    constructor();
+    ngOnDestroy(): void;
+    getClientRect(): DOMRect;
+    toggle(show: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownDirective, "[insDropdown]:not(ng-container):not(ng-template)", ["insDropdown"], { "insDropdown": { "alias": "insDropdown"; "required": false; }; "itemData": { "alias": "itemData"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsDropdownDriverDirective; inputs: {}; outputs: {}; }, { directive: typeof InsDropdownPosition; inputs: {}; outputs: {}; }]>;
+}
+
+declare const INS_ENTER = "ins-enter";
+declare const INS_LEAVE = "ins-leave";
+declare class InsAnimated {
+    private readonly renderer;
+    private readonly el;
+    constructor();
+    protected remove(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAnimated, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsAnimated, "[insAnimated]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsDropdownComponent implements AfterViewInit {
+    private readonly el;
+    private readonly win;
+    private readonly accessor;
+    protected readonly directive: InsDropdownDirective;
+    protected readonly options: _liuk123_insui.InsDropdownOptions;
+    protected readonly styles$: rxjs.Observable<Record<string, string>>;
+    ngAfterViewInit(): void;
+    protected readonly close: () => void;
+    private getStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsDropdownComponent, "ins-dropdown", never, {}, {}, never, never, true, [{ directive: typeof InsActiveZone; inputs: {}; outputs: {}; }, { directive: typeof InsAnimated; inputs: {}; outputs: {}; }]>;
+}
+
+/**
+ * A component to display a dropdown
+ */
+declare const INS_DROPDOWN_COMPONENT: InjectionToken<Type<any>>;
+declare const INS_DROPDOWN_CONTEXT: InjectionToken<Record<any, any>>;
+
+/**
+ * Directive that monitors element visibility
+ */
+declare class InsObscured {
+    private readonly activeZone;
+    private readonly enabled$;
+    private readonly obscured$;
+    readonly insObscured: rxjs.Observable<boolean>;
+    set insObscuredEnabled(enabled: boolean);
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsObscured, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsObscured, "[insObscured]", never, { "insObscuredEnabled": { "alias": "insObscuredEnabled"; "required": false; }; }, { "insObscured": "insObscured"; }, never, never, true, never>;
+}
+
+declare class InsDropdownOpen {
+    private readonly dropdownHost?;
+    insDropdownEnabled: boolean;
+    insDropdownOpen: i0.ModelSignal<boolean>;
+    private readonly directive;
+    readonly el: HTMLElement;
+    private readonly obscured;
+    private readonly cdr;
+    private readonly driver;
+    private readonly dropdown;
+    protected readonly driveEffect: i0.EffectRef;
+    private get host();
+    private readonly activeZone;
+    protected readonly syncSub: rxjs.Subscription;
+    readonly sub: rxjs.Subscription;
+    toggle(open: boolean): void;
+    private update;
+    private drive;
+    protected onEsc(event: Event | KeyboardEvent): void;
+    protected onClick(target: HTMLElement): void;
+    protected onArrow(event: KeyboardEvent, up: boolean): void;
+    protected onKeydown(event: KeyboardEvent): void;
+    private focusDropdown;
+    private get focused();
+    private get editable();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownOpen, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownOpen, "[insDropdown][insDropdownOpen],[insDropdown][insDropdownOpenChange]", never, { "insDropdownEnabled": { "alias": "insDropdownEnabled"; "required": false; }; "insDropdownOpen": { "alias": "insDropdownOpen"; "required": false; "isSignal": true; }; }, { "insDropdownOpen": "insDropdownOpenChange"; }, ["dropdownHost"], never, true, [{ directive: typeof InsObscured; inputs: {}; outputs: {}; }, { directive: typeof InsActiveZone; inputs: { "insActiveZoneParent": "insActiveZoneParent"; }; outputs: { "insActiveZoneChange": "insActiveZoneChange"; }; }]>;
+}
+
+type InsHorizontalDirection = 'left' | 'right';
+type InsVerticalDirection = 'bottom' | 'top';
+
+type InsDropdownAlign = 'center' | 'left' | 'right';
+type InsDropdownWidth = 'auto' | 'fixed' | 'min';
+interface InsDropdownOptions {
+    readonly align: InsDropdownAlign;
+    readonly appearance: string;
+    readonly direction: InsVerticalDirection | null;
+    readonly limitWidth: InsDropdownWidth;
+    readonly maxHeight: number;
+    readonly minHeight: number;
+    readonly offset: number;
+}
+/** Default values for dropdown options */
+declare const INS_DROPDOWN_DEFAULT_OPTIONS: InsDropdownOptions;
+/**
+ * Default parameters for dropdown directive
+ */
+declare const INS_DROPDOWN_OPTIONS: i0.InjectionToken<InsDropdownOptions>;
+declare const insDropdownOptionsProvider: (options: Partial<InsDropdownOptions>) => FactoryProvider;
+declare class InsDropdownOptionsDirective implements InsDropdownOptions {
+    private readonly options;
+    align: InsDropdownAlign;
+    appearance: string;
+    direction: InsVerticalDirection;
+    limitWidth: InsDropdownWidth;
+    minHeight: number;
+    maxHeight: number;
+    offset: number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownOptionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownOptionsDirective, "[insDropdownAlign], [insDropdownAppearance], [insDropdownDirection], [insDropdownLimitWidth], [insDropdownMinHeight], [insDropdownMaxHeight], [insDropdownOffset]", never, { "align": { "alias": "insDropdownAlign"; "required": false; }; "appearance": { "alias": "insDropdownAppearance"; "required": false; }; "direction": { "alias": "insDropdownDirection"; "required": false; }; "limitWidth": { "alias": "insDropdownLimitWidth"; "required": false; }; "minHeight": { "alias": "insDropdownMinHeight"; "required": false; }; "maxHeight": { "alias": "insDropdownMaxHeight"; "required": false; }; "offset": { "alias": "insDropdownOffset"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsDropdownPositionSided extends InsPositionAccessor {
+    private readonly options;
+    private readonly viewport;
+    readonly accessor: InsRectAccessor | null;
+    insDropdownSidedOffset: number;
+    readonly type = "dropdown";
+    private previous;
+    getPosition({ width, height }: DOMRect): InsPoint;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownPositionSided, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownPositionSided, "[insDropdownSided]", never, { "insDropdownSidedOffset": { "alias": "insDropdownSidedOffset"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsCopyProcessor {
+    private readonly win;
+    insCopyProcessor: InsStringHandler<string>;
+    protected onCopy(event: ClipboardEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsCopyProcessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsCopyProcessor, "[insCopyProcessor]", never, { "insCopyProcessor": { "alias": "insCopyProcessor"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare function insCheckFixedPosition(element?: HTMLElement | null): boolean;
+
+declare function containsOrAfter(current: Node, node: Node): boolean;
+
+declare function isInput(element: Element): element is HTMLInputElement;
+declare function isTextarea(element: Element): element is HTMLTextAreaElement;
+declare function isTextfield(element: Element): element is HTMLInputElement | HTMLTextAreaElement;
+declare function isElement(node?: Element | EventTarget | Node | null): node is Element;
+declare function isHTMLElement(node: unknown): node is HTMLElement;
+declare function isTextNode(node: Node): node is Text;
+
+/**
+ * Gets actual target from open Shadow DOM if event happened within it
+ * 在使用 Web Components 或一般 ShadowDOM 时，你可能会在内部有多个可聚焦元素。 window 不会知道 shadow root 内部的聚焦转换。
+ * document.activeElement 将保持不变——即 shadow root 元素。而这个 shadow root 将有它自己的 activeElement 来跟踪真正的聚焦元素
+ * 然而，真正的目标将通过事件上的 composedPath 方法暴露给我们。
+ */
+declare function getActualTarget(event: Event): Node;
+
+declare function getDocumentOrShadowRoot(node: Node): DocumentOrShadowRoot;
+
+/**
+ * Returns array of Elements covering edges of given element or null if at least one edge middle point is visible
+ *
+ * CAUTION: Empty array means element if offscreen i.e. covered by no elements, rather than not covered
+ * ```ts
+ * function insGetElementObscures(element: Element): readonly [Element, Element, Element, Element] | [] | null
+ * ```
+ */
+declare function insGetElementObscures(element: Element): readonly [Element, Element, Element, Element] | [] | null;
+
+/**
+ * @description:
+ * cross browser way to get selected text
+ *
+ * History:
+ * BUG - window.getSelection() fails when text selected in a form field
+ * https://bugzilla.mozilla.org/show_bug.cgi?id=85686
+ */
+declare function insGetSelectedText({ getSelection, document }: Window): string | null;
+
+/**
+ * @description:
+ * Cross-browser @media (height/width)
+ *
+ * 1. window.innerWidth/Width
+ * 1.1. gets CSS viewport @media (height/width) which include scrollbars
+ * 1.2. initial-scale and zoom variations may cause mobile values to
+ *      wrongly scale down to what PPK calls the visual
+ *      viewport and be smaller than the @media values
+ *  1.3. zoom may cause values to be 1px off due to native rounding
+ *
+ *  2. document.documentElement.clientHeight/Width
+ *  2.1. equals CSS viewport width minus scrollbar width
+ *  2.2. matches @media (height) when there is no scrollbar
+ *  2.3. available cross-browser
+ *  2.4. inaccurate if doctype is missing
+ */
+declare function getViewportHeight({ document, innerHeight }: Window): number;
+declare function getViewportWidth({ document, innerWidth }: Window): number;
+
+declare function injectElement<T = HTMLElement>(): T;
+
+declare function insIsElementEditable(element: HTMLElement): boolean;
+
+/**
+ * 获取光标位置的语义化单词范围（支持中文）
+ */
+declare function insGetSemanticWordRange(range: Range): Range;
+/**
+ * Creates a cloned range with its boundaries set at word boundaries
+ *
+ * @param currentRange a range to clone
+ * @return modified range
+ */
+declare function insGetWordRange(currentRange: Range): Range;
+
+declare class InsFade {
+    lineHeight: string | null;
+    size: string;
+    offset: string;
+    orientation: 'horizontal' | 'vertical' | '';
+    constructor();
+    private isEnd;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsFade, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsFade, "[insFade]", never, { "lineHeight": { "alias": "insFadeHeight"; "required": false; }; "size": { "alias": "insFadeSize"; "required": false; }; "offset": { "alias": "insFadeOffset"; "required": false; }; "orientation": { "alias": "insFade"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsFocusTrap implements OnDestroy {
+    private readonly doc;
+    private readonly el;
+    private activeElement;
+    protected initialized: boolean;
+    constructor();
+    ngOnDestroy(): void;
+    protected onBlur(): void;
+    protected onFocusIn(node: Node): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsFocusTrap, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsFocusTrap, "[insFocusTrap]", never, {}, {}, never, never, true, never>;
+}
+
+/**
+ * Finds and blurs current active element, including shadow DOM
+ */
+declare function insBlurNativeFocused(doc: Document): void;
+
+declare function insFocusedIn(node: Node): Signal<boolean>;
+
+interface GetClosestFocusableOptions {
+    /**
+     * @description:
+     * current HTML element
+     */
+    initial: Element;
+    /**
+     * @description:
+     * determine if only keyboard focus is of interest
+     */
+    keyboard?: boolean;
+    /**
+     * @description:
+     * should it look backwards instead (find item that will be focused with Shift + Tab)
+     */
+    previous?: boolean;
+    /**
+     * @description:
+     * top Node limiting the search area
+     */
+    root: Node;
+}
+/**
+ * @description:
+ * Finds the closest element that can be focused with a keyboard or mouse in theory
+ */
+declare function getClosestFocusable({ initial, root, previous, keyboard, }: GetClosestFocusableOptions): HTMLElement | null;
+
+/**
+ * Returns current active element, including shadow dom
+ *
+ * @return element or null
+ */
+declare function getNativeFocused({ activeElement }: Document): Element | null;
+
+/**
+ * Checks if focused element is within given element.
+ *
+ * @param node
+ * @return true if focused node is contained within element
+ */
+declare function isNativeFocusedIn(node?: Node | null): boolean;
+
+/**
+ * Checks if element is focused.
+ *
+ * Could return true even after blur since element remains focused if you switch away from a browser tab.
+ *
+ * @param node or null (as a common return value of DOM nodes walking)
+ * @return true if focused
+ */
+declare function isNativeFocused(node?: Node | null): boolean;
+
+/**
+ * Checks for signs that element can be focused with keyboard. tabIndex above 0 is ignored to
+ * only target natural focus order. Not checking the possibility of an element to
+ * be focused, for example element can have display: none applied to it or any other
+ * circumstances could prevent actual focus.
+ */
+declare function isNativeKeyboardFocusable(element: Element): boolean;
+
+declare function isNativeMouseFocusable(element: Element): boolean;
+
+/**
+ * Utility method for moving focus in a list of elements
+ *
+ * @param currentIndex currently focused index
+ * @param elements array of focusable elements
+ * @param step a step to move focus by, typically -1 or 1
+ */
+declare function insMoveFocus(currentIndex: number, elements: readonly HTMLElement[], step: number): void;
+
+/**
+ * Clamps a value between two inclusive limits
+ *
+ * @param value
+ * @param min lower limit
+ * @param max upper limit
+ */
+declare function insClamp(value: number, min: number, max: number): number;
+
+declare class InsNativeValidator implements Validator {
+    private readonly destroyRef;
+    private readonly zone;
+    private readonly el;
+    private control?;
+    insNativeValidator: i0.InputSignal<string>;
+    validate(control: AbstractControl): ValidationErrors | null;
+    protected handleValidation(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsNativeValidator, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsNativeValidator, "[insNativeValidator]", never, { "insNativeValidator": { "alias": "insNativeValidator"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Service that monitors element visibility by polling and returning
+ * either null or an array of elements that overlap given element edges
+ */
+declare class InsObscuredService extends Observable<readonly Element[] | null> {
+    private readonly el;
+    private readonly obscured$;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsObscuredService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsObscuredService>;
+}
+
+declare class PolymorpheusContext<T> {
+    readonly $implicit: T;
+    constructor($implicit: T);
+    get polymorpheusOutlet(): T;
+}
+
+/**
+ * Use this token to access context within your components when
+ * instantiating them through {@link PolymorpheusOutlet}
+ */
+declare const POLYMORPHEUS_CONTEXT: InjectionToken<Record<any, any>>;
+
+declare class PolymorpheusOutlet<C> implements OnChanges, DoCheck {
+    private readonly vcr;
+    private readonly i;
+    private readonly t;
+    private c?;
+    content: PolymorpheusContent<C>;
+    context?: C;
+    static ngTemplateContextGuard<T>(_dir: PolymorpheusOutlet<T>, _ctx: any): _ctx is PolymorpheusContext<T extends PolymorpheusPrimitive ? T : never>;
+    ngOnChanges({ content }: SimpleChanges): void;
+    ngDoCheck(): void;
+    private get template();
+    private getContext;
+    private process;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PolymorpheusOutlet<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PolymorpheusOutlet<any>, "[polymorpheusOutlet]", never, { "content": { "alias": "polymorpheusOutlet"; "required": false; }; "context": { "alias": "polymorpheusOutletContext"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+interface InsSwipeEvent {
+    readonly direction: InsSwipeDirection;
+    readonly events: [TouchEvent, TouchEvent];
+}
+type InsSwipeDirection = 'bottom' | 'left' | 'right' | 'top';
+interface InsSwipeOptions {
+    readonly threshold: number;
+    readonly timeout: number;
+}
+
+declare class InsSwipeService extends Observable<InsSwipeEvent> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsSwipeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsSwipeService>;
+}
+
+declare class InsSwipe {
+    readonly insSwipe: InsSwipeService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsSwipe, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsSwipe, "[insSwipe]", never, {}, { "insSwipe": "insSwipe"; }, never, never, true, never>;
+}
+
+declare const INS_SWIPE_OPTIONS: i0.InjectionToken<InsSwipeOptions>;
+
+interface InsZoomEvent {
+    readonly clientX: number;
+    readonly clientY: number;
+    readonly delta: number;
+    readonly event: TouchEvent | WheelEvent;
+}
+interface InsZoomOptions {
+    readonly wheelSensitivity: number;
+}
+
+declare class InsZoomService extends Observable<InsZoomEvent> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsZoomService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsZoomService>;
+}
+
+declare class InsZoom {
+    protected readonly insZoom: InsZoomService;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsZoom, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsZoom, "[insZoom]", never, {}, { "insZoom": "insZoom"; }, never, never, true, never>;
+}
+
+/**
+ * Zoom options
+ */
+declare const INS_ZOOM_OPTIONS: i0.InjectionToken<InsZoomOptions>;
+
+interface InsMedia {
+    readonly desktopLarge: number;
+    readonly desktopSmall: number;
+    readonly mobile: number;
+    readonly tablet?: number;
+}
+/**
+ * Token for media constant
+ */
+declare const INS_MEDIA: i0.InjectionToken<InsMedia>;
+
+type InsBreakpointMediaKey = keyof Omit<InsMedia, 'tablet'>;
+/**
+ * Service to provide the current breakpoint based on Taiga UI's media queries
+ */
+declare class InsBreakpointService extends Observable<InsBreakpointMediaKey | null> {
+    private readonly media;
+    private readonly win;
+    private readonly stream$;
+    constructor();
+    private getQueries;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsBreakpointService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsBreakpointService>;
+}
+
+declare function createToken<T>(defaults?: T): InjectionToken<T>;
+declare function createTokenFromFactory<T>(factory: () => T): InjectionToken<T>;
+
+/**
+ * Generates unique ids
+ */
+declare class InsIdService {
+    private static autoId;
+    generate(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsIdService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsIdService>;
+}
+declare function insInjectId(): string;
+
+declare function insIfMap<T, G>(project: (value: T) => Observable<G>, predicate?: InsBooleanHandler<T>): OperatorFunction<T, G>;
+
+declare class InsResize implements OnDestroy {
+    private readonly el;
+    protected resizeObserver: ResizeObserver | null;
+    insResize: EventEmitter<ResizeObserverEntry>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsResize, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsResize, "[insResize]", never, {}, { "insResize": "insResize"; }, never, never, true, never>;
+}
+
+/**
+ * Check if pressed key is interactive in terms of input field
+ */
+declare function isEditingKey(key?: string): boolean;
+
+declare function isPresent<T>(value?: T | null): value is T;
+
+declare function insMarkControlAsTouchedAndValidate(control: AbstractControl): void;
+
+declare function insOverrideOptions<T>(override: Partial<T>, fallback: T): (directive: T | null, options: T | null) => T;
+
+/**
+ * Abstract class for host element for dynamically created portals.
+ */
+declare abstract class InsPortals {
+    private readonly vcr;
+    private readonly injector;
+    constructor();
+    addComponent<C>(component: PolymorpheusComponent<C>): ComponentRef<C>;
+    addTemplate<C>(templateRef: TemplateRef<C>, context?: C): EmbeddedViewRef<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPortals, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsPortals, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class InsPortalService {
+    protected host?: InsPortals;
+    attach(host: InsPortals): void;
+    add<C>(content: PolymorpheusComponent<C>): ComponentRef<C>;
+    add<C>(content: TemplateRef<C>, context?: C): EmbeddedViewRef<C>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPortalService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsPortalService>;
+}
+declare class InsNoHostException extends Error {
+    constructor();
+}
+
+/**
+ * For type safety when using @ContentChildren and @ViewChildren
+ *
+ * NOTE: Be careful subscribing to 'changes'
+ */
+declare const EMPTY_QUERY: QueryList<any>;
+declare const EMPTY_ARRAY: [];
+declare const EMPTY_FUNCTION: (...args: any[]) => void;
+declare const EMPTY_CLIENT_RECT: DOMRect;
+
+/**
+ * Typed mapping function.
+ */
+type InsMapper<T extends unknown[], G> = (...args: T) => G;
+
+/**
+ * A matcher function to test items against with extra arguments.
+ */
+type InsMatcher<I extends unknown[]> = InsMapper<I, boolean>;
+type InsStringMatcher<I> = (item: I, matchValue: string, stringify: InsStringHandler<I>) => boolean;
+type InsIdentityMatcher<I> = (item1: I, item2: I) => boolean;
+
+type InsPortalContext<T, O = void> = T & InsContext<Observer<O>> & {
+    readonly content: PolymorpheusContent<InsPortalContext<T, O>>;
+    readonly createdAt: number;
+    readonly id: string;
+    completeWith(value: O): void;
+};
+declare abstract class InsPortal<T, K = void> {
+    protected readonly service: InsPortalService;
+    protected abstract readonly component: Type<any>;
+    protected abstract readonly options: T;
+    private readonly injector;
+    private readonly id;
+    constructor(service: InsPortalService);
+    open<G = void>(content: PolymorpheusContent<InsPortalContext<T, K extends void ? G : K>>, options?: Partial<T>): Observable<K extends void ? G : K>;
+    protected add(component: PolymorpheusComponent<unknown>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPortal<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsPortal<any, any>>;
+}
+declare function insAsPortal(portal: typeof InsPortal<any>): Provider;
+
+declare class InsPortalDirective<T> extends PolymorpheusTemplate<InsPortalContext<T>> {
+    private readonly service;
+    readonly options: i0.InputSignal<Partial<T>>;
+    readonly open: i0.InputSignal<boolean>;
+    readonly openChange: i0.OutputRef<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPortalDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsPortalDirective<any>, never, never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "openChange": "openChange"; }, never, never, true, never>;
+}
+
+declare class InsPositionService extends Observable<Readonly<[x: number, y: number]>> {
+    private readonly el;
+    private readonly accessor;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPositionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsPositionService>;
+}
+
+declare function provideOptions<T>(provide: InjectionToken<T>, options: Partial<T>, fallback: T): FactoryProvider;
+
+declare function insProvide<T>(provide: ProviderToken<T>, useExisting: ProviderToken<T>): ExistingProvider;
+declare function insProvide<T>(provide: ProviderToken<T | T[]>, useExisting: ProviderToken<T>, multi: boolean): ExistingProvider;
+
+declare const svgNodeFilter: Exclude<NodeFilter, (node: Node) => number>;
+
+declare function insWithStyles(component: Type<unknown>): undefined;
+
+declare function insZonefull<T>(zone?: NgZone): MonoTypeOperatorFunction<T>;
+declare function insZonefree<T>(zone?: NgZone): MonoTypeOperatorFunction<T>;
+declare function insZoneOptimized<T>(zone?: NgZone): MonoTypeOperatorFunction<T>;
+declare function insZonefreeScheduler(zone?: NgZone, scheduler?: SchedulerLike): SchedulerLike;
+declare function insZonefullScheduler(zone?: NgZone, scheduler?: SchedulerLike): SchedulerLike;
+
+declare class InsPresent implements OnDestroy {
+    readonly insPresent: i0.OutputEmitterRef<boolean>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPresent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsPresent, "[insPresent]", never, {}, { "insPresent": "insPresent"; }, never, never, true, never>;
+}
+
+declare function insArrayToggle<T>(array: readonly T[], item: T, identity?: InsIdentityMatcher<T>): T[];
+declare function insArrayRemove<T>(array: readonly T[], index: number): T[];
+
+interface InsPositionOptions {
+    readonly block: 'end' | 'start';
+    readonly inline: 'center' | 'end' | 'start';
+}
+declare class InsNotificationDirective {
+    protected readonly nothing: undefined;
+    readonly context: InsPortalContext<InsPositionOptions>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsNotificationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsNotificationDirective, never, never, {}, {}, never, never, true, never>;
+}
+
+declare abstract class InsNotificationService<T, K = void> extends InsPortal<T, K> {
+    private readonly concurrency;
+    private readonly current;
+    private readonly queue;
+    constructor(concurrency: number);
+    protected add(component: PolymorpheusComponent<unknown>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsNotificationService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsNotificationService<any, any>>;
+}
+
+declare class InsDropdownHover extends InsDriver {
+    private readonly dropdownHost?;
+    private readonly el;
+    private readonly doc;
+    private readonly options;
+    private readonly activeZone;
+    private readonly open;
+    /**
+       * Dropdown can be removed not only via click/touch –
+       * swipe on mobile devices removes dropdown sheet without triggering new mouseover / mouseout events.
+       */
+    private readonly dropdownExternalRemoval$;
+    private readonly stream$;
+    hovered: boolean;
+    readonly type = "dropdown";
+    showDelay: number;
+    hideDelay: number;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    private isHovered;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownHover, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownHover, "[insDropdownHover]", never, { "showDelay": { "alias": "insDropdownShowDelay"; "required": false; }; "hideDelay": { "alias": "insDropdownHideDelay"; "required": false; }; }, {}, ["dropdownHost"], never, true, never>;
+}
+
+declare class InsDropdownSelection extends InsDriver implements InsRectAccessor, OnDestroy {
+    private ghost?;
+    protected readonly doc: Document;
+    protected readonly vcr: ViewContainerRef;
+    protected readonly dropdown: InsDropdownDirective;
+    protected readonly el: HTMLElement;
+    protected readonly handler: i0.Signal<InsBooleanHandler<Range>>;
+    protected readonly stream$: rxjs.Observable<boolean>;
+    protected range: Range;
+    readonly type = "dropdown";
+    readonly insDropdownSelection: i0.InputSignal<string | InsBooleanHandler<Range>>;
+    readonly insDropdownSelectionPosition: i0.InputSignal<"word" | "selection" | "tag">;
+    constructor();
+    getClientRect(): DOMRect;
+    ngOnDestroy(): void;
+    private get ghostHost();
+    private getRange;
+    /**
+     * Check if given range is at least partially inside dropdown
+     */
+    private inDropdown;
+    /**
+     * Check if Node is inside dropdown
+     */
+    private boxContains;
+    /**
+     * Check if range is not inside ins-textfield's DOM elements
+     */
+    private isValid;
+    private veryVerySadInputFix;
+    /**
+     * Create an invisible DIV styled exactly like input/textarea element inside directive
+     */
+    private initGhost;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownSelection, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownSelection, "[insDropdownSelection]", never, { "insDropdownSelection": { "alias": "insDropdownSelection"; "required": false; "isSignal": true; }; "insDropdownSelectionPosition": { "alias": "insDropdownSelectionPosition"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 暂时没有使用
+ */
+declare class InsDropdownContent implements OnDestroy {
+    private readonly directive;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDropdownContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDropdownContent, "ng-template[insDropdown]", never, {}, {}, never, never, true, never>;
+}
+
+declare const InsDropdown: readonly [typeof InsDropdownOptionsDirective, typeof InsDropdownDriverDirective, typeof InsDropdownDirective, typeof InsDropdownComponent, typeof InsDropdownOpen, typeof InsDropdownPosition, typeof InsDropdownPositionSided, typeof InsDropdownHover, typeof InsDropdownSelection, typeof InsDropdownContent];
+
+declare class InsWithDropdownOpen {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsWithDropdownOpen, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsWithDropdownOpen, never, never, {}, {}, never, never, true, [{ directive: typeof InsDropdownOpen; inputs: { "insDropdownOpen": "open"; "insDropdownEnabled": "insDropdownEnabled"; }; outputs: { "insDropdownOpenChange": "openChange"; }; }]>;
+}
+
+interface InsDropdownHoverOptions {
+    readonly hideDelay: number;
+    readonly showDelay: number;
+}
+/** Default values for hint options */
+declare const INS_DROPDOWN_HOVER_DEFAULT_OPTIONS: InsDropdownHoverOptions;
+/**
+ * Default parameters for dropdown hover directive
+ */
+declare const INS_DROPDOWN_HOVER_OPTIONS: InjectionToken<InsDropdownHoverOptions>;
+declare function insDropdownHoverOptionsProvider(options: Partial<InsDropdownHoverOptions>): Provider;
+
+declare const INS_CHEVRON: i0.InjectionToken<string>;
+declare class InsChevron {
+    protected readonly dropdown: InsDropdownDirective;
+    protected readonly nothing: undefined;
+    readonly chevron: i0.WritableSignal<boolean | "">;
+    protected isRotated: i0.Signal<boolean>;
+    set setChevron(val: boolean | '');
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsChevron, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsChevron, "[insChevron]", never, { "setChevron": { "alias": "insChevron"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsAccordionDirective implements OnChanges {
+    private readonly accordion;
+    private readonly insChevron;
+    private readonly insButton;
+    insAccordion: i0.ModelSignal<string | boolean>;
+    constructor();
+    readonly open: i0.WritableSignal<boolean>;
+    ngOnChanges(): void;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAccordionDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsAccordionDirective, "button[insAccordion]", never, { "insAccordion": { "alias": "insAccordion"; "required": false; "isSignal": true; }; }, { "insAccordion": "insAccordionChange"; }, never, never, true, [{ directive: typeof InsButton; inputs: {}; outputs: {}; }, { directive: typeof InsChevron; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsGroup {
+    private readonly options;
+    protected readonly nothing: undefined;
+    orientation: 'horizontal' | 'vertical';
+    collapsed: boolean;
+    rounded: boolean;
+    size: 's' | 'm' | 'l';
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsGroup, "[insGroup]:not(ng-container)", never, { "orientation": { "alias": "orientation"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; "rounded": { "alias": "rounded"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsAccordionComponent {
+    protected readonly expands: i0.Signal<readonly InsExpand[]>;
+    protected readonly directives: i0.Signal<readonly InsAccordionDirective[]>;
+    readonly closeOthers: i0.InputSignal<boolean>;
+    readonly size: i0.InputSignal<"s" | "m" | "l">;
+    toggle(directive: InsAccordionDirective): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAccordionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsAccordionComponent, "ins-accordion", never, { "closeOthers": { "alias": "closeOthers"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["expands", "directives"], ["*"], true, [{ directive: typeof InsGroup; inputs: {}; outputs: {}; }]>;
+}
+
+declare const InsAccordion: readonly [typeof InsAccordionComponent, typeof InsAccordionDirective, typeof InsExpand];
+
+/**
+ * Bundled appearances for autocomplete purposes, not exported on purpose
+ */
+type Appearance = 'accent' | 'action-destructive' | 'action-grayscale' | 'action' | 'flat-destructive' | 'flat-grayscale' | 'flat' | 'glass' | 'icon' | 'info' | 'negative' | 'neutral' | 'outline-destructive' | 'outline-grayscale' | 'outline' | 'positive' | 'primary-destructive' | 'primary-grayscale' | 'primary' | 'secondary-destructive' | 'secondary-grayscale' | 'secondary' | 'textfield' | (Record<never, never> & string);
+interface InsAppearanceOptions {
+    readonly appearance: Appearance;
+}
+declare const INS_APPEARANCE_DEFAULT_OPTIONS: InsAppearanceOptions;
+declare const INS_APPEARANCE_OPTIONS: i0.InjectionToken<InsAppearanceOptions>;
+declare function insAppearanceOptionsProvider(token: ProviderToken<InsAppearanceOptions>): ExistingProvider;
+
+interface InsNotificationOptions extends InsAppearanceOptions {
+    readonly icon: InsStringHandler<string> | string;
+    readonly size: 's' | 'm' | 'l';
+}
+declare const INS_NOTIFICATION_DEFAULT_OPTIONS: InsNotificationOptions;
+/**
+ * Default parameters for notification alert component
+ */
+declare const INS_NOTIFICATION_OPTIONS: i0.InjectionToken<InsNotificationOptions>;
+declare function insNotificationOptionsProvider(options: Partial<InsNotificationOptions>): Provider;
+
+interface InsAlertOptions<I = undefined> extends Omit<InsNotificationOptions, 'size'>, InsPositionOptions {
+    readonly autoClose: InsHandler<string, number> | number;
+    readonly data: I;
+    readonly closeable: boolean;
+    readonly label: PolymorpheusContent<InsAlertOptions<I>>;
+}
+type InsAlertContext<O = void, I = undefined> = InsPortalContext<InsAlertOptions<I>, O>;
+
+declare class InsAlertComponent<O, I> {
+    private readonly el;
+    protected readonly icons: _liuk123_insui.InsCommonIcons;
+    protected readonly item: InsPortalContext<InsAlertOptions<I>, O>;
+    protected readonly close: i0.Signal<string>;
+    protected readonly sub: rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAlertComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsAlertComponent<any, any>, "ins-alert", never, {}, {}, never, never, true, [{ directive: typeof InsAnimated; inputs: {}; outputs: {}; }, { directive: typeof InsNotificationDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsAlert<T> {
+    readonly insAlertOptions: i0.InputSignal<Partial<InsAlertOptions<T>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAlert<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsAlert<any>, "ng-template[insAlert]", never, { "insAlertOptions": { "alias": "insAlertOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsPortalDirective; inputs: { "options": "insAlertOptions"; "open": "insAlert"; }; outputs: { "openChange": "insAlertChange"; }; }]>;
+}
+
+declare class InsAlertService extends InsNotificationService<InsAlertOptions<any>> {
+    protected readonly options: InsAlertOptions<undefined>;
+    protected readonly component: typeof InsAlertComponent;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAlertService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsAlertService>;
+}
+
+declare const INS_ALERT_CONCURRENCY: i0.InjectionToken<number>;
+declare const INS_ALERT_DEFAULT_OPTIONS: Omit<InsAlertOptions, 'appearance' | 'icon'>;
+declare const INS_ALERT_OPTIONS: i0.InjectionToken<InsAlertOptions<undefined>>;
+declare function insAlertOptionsProvider(options: Partial<InsAlertOptions>): FactoryProvider;
+
+declare class InsAvatar {
+    protected readonly nothing: undefined;
+    private readonly options;
+    size: i0.InputSignal<"s" | "m" | "l" | "xs" | "xl" | "xxl" | "xxxl">;
+    round: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsAvatar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsAvatar, "ins-avatar,button[insAvatar],a[insAvatar]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "round": { "alias": "round"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, [{ directive: typeof InsWithAppearance; inputs: {}; outputs: {}; }]>;
+}
+
+interface InsAvatarOptions extends InsAppearanceOptions {
+    readonly appearance: string;
+    readonly round: boolean;
+    readonly size: 'xs' | 's' | 'm' | 'l' | 'xl' | 'xxl' | 'xxxl';
+}
+declare const INS_AVATAR_DEFAULT_OPTIONS: InsAvatarOptions;
+declare const INS_AVATAR_OPTIONS: i0.InjectionToken<InsAvatarOptions>;
+declare function insAvatarOptionsProvider(options: Partial<InsAvatarOptions>): Provider;
+
+interface InsButtonOptions extends InsAppearanceOptions {
+    readonly size: 'xs' | 's' | 'm' | 'l';
+}
+declare const INS_BUTTON_DEFAULT_OPTIONS: InsButtonOptions;
+declare const INS_BUTTON_OPTIONS: i0.InjectionToken<InsButtonOptions>;
+declare function insButtonOptionsProvider(options: Partial<InsButtonOptions>): FactoryProvider;
+
+declare class InsButtonLoading {
+    private readonly options;
+    size: i0.InputSignal<"s" | "m" | "l" | "xs">;
+    loading: i0.InputSignal<string | boolean>;
+    protected label: i0.Signal<string | boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsButtonLoading, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsButtonLoading, "[insButton][loading],[insIconButton][loading]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class InsCheckbox implements OnInit, DoCheck {
+    private readonly appearance;
+    private readonly options;
+    private readonly resolver;
+    private readonly el;
+    private readonly destroyRef;
+    private readonly cdr;
+    size: i0.InputSignal<"s" | "m" | "l">;
+    readonly control: NgControl | null;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    protected iconChecked: i0.Signal<string>;
+    protected iconIndeterminate: i0.Signal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsCheckbox, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsCheckbox, "input[type=\"checkbox\"][insCheckbox]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsAppearance; inputs: { "insAppearanceState": "insAppearanceState"; "insAppearanceFocus": "insAppearanceFocus"; "insAppearanceMode": "insAppearanceMode"; }; outputs: {}; }, { directive: typeof InsNativeValidator; inputs: {}; outputs: {}; }]>;
+}
+
+interface InsCheckboxOptions {
+    readonly size: 's' | 'm' | 'l';
+    readonly appearance: InsStringHandler<HTMLInputElement> | string;
+    readonly icons: Readonly<{
+        checked: InsStringHandler<'s' | 'm' | 'l'> | string;
+        indeterminate: InsStringHandler<'s' | 'm' | 'l'> | string;
+    }>;
+}
+declare const INS_CHECKBOX_DEFAULT_OPTIONS: InsCheckboxOptions;
+declare const INS_CHECKBOX_OPTIONS: i0.InjectionToken<InsCheckboxOptions>;
+declare function insCheckboxOptionsProvider(options: Partial<InsCheckboxOptions>): Provider;
+
+declare class InsChip {
+    private readonly options;
+    protected readonly nothing: undefined;
+    size: 'xs' | 's' | 'm' | 'l';
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsChip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsChip, "[insChip]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof InsWithIcons; inputs: {}; outputs: {}; }]>;
+}
+
+interface InsChipOptions extends InsAppearanceOptions {
+    readonly size: 'xs' | 's' | 'm' | 'l';
+}
+declare const INS_CHIP_DEFAULT_OPTIONS: InsChipOptions;
+declare const INS_CHIP_OPTIONS: i0.InjectionToken<InsChipOptions>;
+declare function insChipOptionsProvider(options: Partial<InsChipOptions>): Provider;
+
+interface InsDataListAccessor<T = unknown> {
+    getOptions(includeDisabled?: boolean): readonly T[];
+}
+interface InsDataListHost<T> {
+    handleOption(option: T): void;
+    readonly identityMatcher?: InsIdentityMatcher<T>;
+    readonly stringify?: InsStringHandler<T>;
+    readonly size: InputSignal<'xs' | 's' | 'm' | 'l'>;
+}
+/**
+ * Content for insOption component
+ */
+/**
+ * Accessor for data-list options
+ */
+declare const INS_DATA_LIST_ACCESSOR: InjectionToken<InsDataListAccessor<unknown>>;
+declare function insAsDataListAccessor(accessor: Type<InsDataListAccessor>): Provider;
+/**
+* DataList controller
+*/
+declare const INS_DATA_LIST_HOST: InjectionToken<InsDataListHost<unknown>>;
+declare function insAsDataListHost<T>(host: Type<InsDataListHost<T>>): Provider;
+
+declare class InsDataListComponent<T> implements InsDataListAccessor {
+    private origin?;
+    private readonly el;
+    private readonly nothing;
+    private readonly options;
+    protected readonly empty: i0.Signal<boolean>;
+    protected readonly fallback: i0.Signal<string>;
+    size: i0.InputSignal<"s" | "m" | "l" | "xs">;
+    emptyContent: i0.InputSignal<PolymorpheusContent<any>>;
+    onKeyDownArrow(current: HTMLElement, step: number): void;
+    handleFocusLossIfNecessary(element?: Element): void;
+    getOptions(includeDisabled?: boolean): readonly T[];
+    protected onFocusIn(relatedTarget: HTMLElement, currentTarget: HTMLElement): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDataListComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsDataListComponent<any>, "ins-data-list", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "emptyContent": { "alias": "emptyContent"; "required": false; "isSignal": true; }; }, {}, ["options"], ["*"], true, never>;
+}
+
+declare class InsOptGroup {
+    label?: string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsOptGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsOptGroup, "ins-opt-group", never, { "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsOption<T = unknown> implements OnDestroy {
+    private readonly el;
+    private readonly dataList;
+    private readonly host;
+    disabled: boolean;
+    value?: T;
+    ngOnDestroy(): void;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsOption<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsOption<any>, "button[insOption], a[insOption], label[insOption]", never, { "disabled": { "alias": "disabled"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsWithIcons; inputs: {}; outputs: {}; }]>;
+}
+
+declare const InsDataList: readonly [typeof InsDataListComponent, typeof InsOption, typeof InsOptGroup];
+
+interface InsDialogOptions<I> extends InsAppearanceOptions {
+    readonly closable: Observable<boolean> | boolean;
+    readonly data: I extends void ? undefined : I & {
+        button?: string;
+    };
+    readonly dismissible: Observable<boolean> | boolean;
+    readonly label: string;
+    readonly required: boolean;
+    readonly size: 's' | 'm' | 'l';
+}
+type InsDialogContext<O = void, I = undefined> = InsPortalContext<InsDialogOptions<I>, O>;
+declare const INS_DIALOG_DEFAULT_OPTIONS: InsDialogOptions<void>;
+declare const INS_DIALOG_OPTIONS: i0.InjectionToken<InsDialogOptions<void>>;
+
+declare class InsDialogComponent<O, I> {
+    protected readonly close$: Subject<void>;
+    protected readonly context: InsPortalContext<InsDialogOptions<I>, O>;
+    protected readonly icons: _liuk123_insui.InsCommonIcons;
+    protected readonly close: i0.Signal<string>;
+    protected readonly sub: rxjs.Subscription;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDialogComponent<any, any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsDialogComponent<any, any>, "ins-dialog", never, {}, {}, never, never, true, [{ directive: typeof InsAnimated; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsDialog<T> {
+    readonly insDialogOptions: i0.InputSignal<Partial<InsDialogOptions<T>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDialog<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsDialog<any>, "ng-template[insDialog]", never, { "insDialogOptions": { "alias": "insDialogOptions"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsPortalDirective; inputs: { "options": "insDialogOptions"; "open": "insDialog"; }; outputs: { "openChange": "insDialogChange"; }; }]>;
+}
+
+declare class InsModalComponent<T> implements OnDestroy, OnInit {
+    private readonly current;
+    private readonly parent;
+    readonly context: InsPortalContext<T>;
+    readonly component: i0.WritableSignal<PolymorpheusContent<InsPortalContext<T>>>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsModalComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsModalComponent<any>, "ins-modal", never, {}, {}, never, never, true, [{ directive: typeof InsActiveZone; inputs: {}; outputs: {}; }, { directive: typeof InsFocusTrap; inputs: {}; outputs: {}; }]>;
+}
+
+declare abstract class InsModalService<T, K = void> extends InsPortal<T, K> {
+    protected abstract readonly content: Type<unknown>;
+    protected readonly component: typeof InsModalComponent;
+    constructor();
+    protected add(component: PolymorpheusComponent<InsModalComponent<T>>): () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsModalService<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsModalService<any, any>>;
+}
+
+declare class InsDialogService extends InsModalService<InsDialogOptions<any>> {
+    protected readonly options: InsDialogOptions<void>;
+    protected readonly content: typeof InsDialogComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsDialogService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsDialogService>;
+}
+
+declare class InsValidationError<T extends Record<string, any> = Record<string, unknown>> {
+    readonly message: PolymorpheusContent<T>;
+    readonly context: T;
+    constructor(message: PolymorpheusContent<T>, context?: T);
+}
+
+declare class InsError {
+    protected readonly default: i0.Signal<string>;
+    readonly error: i0.InputSignalWithTransform<InsValidationError<Record<string, unknown>>, string | InsValidationError<Record<string, unknown>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsError, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsError, "ins-error", never, { "error": { "alias": "error"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class FieldErrorPipe implements PipeTransform {
+    errorInfo: Record<string, _liuk123_insui.PolymorpheusContent | rxjs.Observable<_liuk123_insui.PolymorpheusContent>>;
+    transform(value: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldErrorPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FieldErrorPipe, "fieldError", true>;
+}
+
+type InsFileState = 'deleted' | 'error' | 'loading' | 'normal';
+interface InsFileLike {
+    readonly name: string;
+    readonly size?: number;
+    readonly src?: string;
+    readonly type?: string;
+}
+
+interface InsFormOptions {
+    size: 's' | 'm' | 'l';
+    cleaner: boolean;
+    orientation: 'horizontal' | 'vertical' | '';
+}
+declare const INS_FORM_DEFAULT_OPTIONS: InsFormOptions;
+declare const INS_FORM_OPTIONS: i0.InjectionToken<InsFormOptions>;
+declare function insFormOptionsProvider(options: Partial<InsFormOptions>): Provider;
+
+declare class InsForm {
+    protected readonly nothing: undefined;
+    protected readonly options: InsFormOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsForm, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsForm, "[insForm]", never, {}, {}, never, never, true, never>;
+}
+
+interface InsGroupOptions {
+    readonly size: 's' | 'm' | 'l';
+    readonly collapsed: boolean;
+    readonly rounded: boolean;
+    readonly orientation: 'horizontal' | 'vertical';
+}
+declare const INS_GROUP_DEFAULT_OPTIONS: InsGroupOptions;
+declare const INS_GROUP_OPTIONS: i0.InjectionToken<InsGroupOptions>;
+declare function insGroupOptionsProvider(options: Partial<InsGroupOptions>): Provider;
+
+declare const INS_ICON_STARTS: i0.InjectionToken<Record<string, string>>;
+declare function insIconsProvider(icons: Record<string, string>): FactoryProvider;
+
+declare class InsIcon {
+    protected readonly path: string;
+    protected readonly icons: Record<string, string>;
+    protected nothing: undefined;
+    resolver(icon: string): string;
+    readonly icon: i0.InputSignalWithTransform<string, string>;
+    resolve(value?: string | null): string | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsIcon, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsIcon, "ins-icon", never, { "icon": { "alias": "icon"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const INS_ASSETS_PATH: i0.InjectionToken<string>;
+declare function insAssetsPathProvider(useValue: string): ValueProvider;
+declare const INS_ICON_START: i0.InjectionToken<string>;
+declare const INS_ICON_END: i0.InjectionToken<string>;
+
+interface InsTextfieldOptions {
+    readonly appearance: string;
+    readonly size: 'xs' | 's' | 'm' | 'l';
+    readonly cleaner: boolean;
+}
+declare const INS_TEXTFIELD_DEFAULT_OPTIONS: InsTextfieldOptions;
+declare const INS_TEXTFIELD_OPTIONS: InjectionToken<InsTextfieldOptions>;
+declare function insTextfieldOptionsProvider(options: Partial<InsTextfieldOptions>): Provider;
+interface InsTextFieldAccessor<T> {
+    setValue(value: T | T[] | null): void;
+    getValue(): T | T[] | null;
+    clearValue(): void;
+    setFocused(event: MouseEvent | any): void;
+    id: string;
+}
+declare const INS_TEXTFIELD_ACCESSOR: InjectionToken<InsTextFieldAccessor<unknown>>;
+
+declare abstract class InsValueTransformer<From, To = unknown> {
+    abstract toControlValue(componentValue: From): To;
+    abstract fromControlValue(controlValue: To): From;
+}
+
+/**
+ * Basic ControlValueAccessor class to build form components upon
+ */
+declare abstract class InsControl<T> implements ControlValueAccessor {
+    private readonly fallback;
+    private readonly refresh$;
+    private readonly internal;
+    protected readonly control: NgControl;
+    protected readonly cdr: ChangeDetectorRef;
+    protected transformer: InsValueTransformer<any, any>;
+    readonly value: i0.Signal<T>;
+    readonly readOnly: i0.InputSignal<boolean>;
+    readonly pseudoInvalid: i0.InputSignal<boolean>;
+    readonly touched: i0.WritableSignal<boolean>;
+    readonly status: i0.WritableSignal<FormControlStatus>;
+    readonly disabled: i0.Signal<boolean>;
+    readonly interactive: i0.Signal<boolean>;
+    readonly invalid: i0.Signal<boolean>;
+    readonly mode: i0.Signal<"readonly" | "valid" | "invalid">;
+    onTouched: (...args: any[]) => void;
+    onChange: (value: T) => void;
+    constructor();
+    registerOnChange(onChange: (value: unknown) => void): void;
+    registerOnTouched(onTouched: () => void): void;
+    setDisabledState(): void;
+    writeValue(value: T | null): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsControl<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsControl<any>, never, never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "pseudoInvalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsTextfieldDirective {
+    private readonly textfield;
+    private readonly appearance;
+    readonly options: _liuk123_insui.InsTextfieldOptions;
+    invalid: i0.InputSignal<boolean>;
+    focused: i0.InputSignal<boolean>;
+    readOnly: i0.InputSignal<boolean>;
+    disabled: i0.InputSignal<boolean>;
+    mode: i0.Signal<"readonly" | "valid" | "invalid">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextfieldDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTextfieldDirective, never, never, { "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "focused": { "alias": "focused"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsWithAppearance; inputs: {}; outputs: {}; }, { directive: typeof InsNativeValidator; inputs: {}; outputs: {}; }]>;
+}
+
+declare class TextfieldOptionItem {
+    data: any;
+    constructor(data: any);
+    static toString: (data: any) => string;
+    static toValue: (data: any) => any;
+    static identityMatcher: (a: any, b: any) => boolean;
+}
+declare class InsInputTagComponent<T> extends InsControl<T[]> implements InsTextFieldAccessor<T>, OnInit {
+    private readonly template?;
+    id: string;
+    protected icons: _liuk123_insui.InsCommonIcons;
+    protected destroyRef: DestroyRef;
+    private readonly options;
+    private readonly apprearance;
+    private readonly vcr;
+    private readonly tags;
+    private readonly focusableElement?;
+    disabledItemHandler: i0.InputSignal<InsBooleanHandler<any>>;
+    inputHidden: i0.InputSignal<boolean>;
+    placeholder: i0.InputSignal<string>;
+    searchValue: FormControl<string>;
+    searchChange: EventEmitter<string>;
+    searchSignal: i0.Signal<string>;
+    computedPlaceholder: i0.Signal<string>;
+    showGhost: i0.Signal<"hidden" | "visible">;
+    ngOnInit(): void;
+    setValue(value: T[] | T): void;
+    clearValue(): void;
+    getValue(): any;
+    removeItem(index: number): void;
+    get nativeFocusableElement(): HTMLInputElement | null;
+    private focusInput;
+    protected onTagKeyDownArrowLeft(currentIndex: number): void;
+    protected onTagKeyDownArrowRight(currentIndex: number): void;
+    private onScrollKeyDown;
+    setFocused(event: MouseEvent): void;
+    get hasNativeValue(): boolean;
+    protected onFieldKeyDownArrowLeft(event: Event): void;
+    protected onFieldKeyDownBackspace(event: Event): void;
+    protected onFieldKeyDownEnter(): void;
+    private addTag;
+    private deleteLastEnabledItem;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsInputTagComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsInputTagComponent<any>, "ins-input-tag", never, { "disabledItemHandler": { "alias": "disabledItemHandler"; "required": false; "isSignal": true; }; "inputHidden": { "alias": "inputHidden"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, { "searchChange": "searchChange"; }, never, never, true, [{ directive: typeof InsTextfieldDirective; inputs: { "invalid": "invalid"; "focused": "focused"; "readOnly": "readOnly"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+interface InsInputTagOptions extends InsAppearanceOptions {
+    inputHidden: boolean;
+}
+declare const INS_INPUT_TAG_DEFAULT_OPTIONS: InsInputTagOptions;
+declare const INS_INPUT_TAG_OPTIONS: i0.InjectionToken<InsInputTagOptions>;
+declare function insInputTagOptionsProvider(options: Partial<InsInputTagOptions>): Provider;
+
+/**
+ * Blank directive for queries via `@ContentChildren` / `@ViewChildren` / `querySelector`
+ */
+declare class InsItem {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsItem, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsItem, "[insItem]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsLabel {
+    private readonly options;
+    orientation: i0.InputSignal<"" | "horizontal" | "vertical">;
+    protected readonly nothing: undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsLabel, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsLabel, "label[insLabel]", never, { "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface InsLabelOptions {
+    orientation: 'horizontal' | 'vertical' | '';
+}
+declare const INS_LABEL_DEFAULT_OPTIONS: InsLabelOptions;
+declare const INS_LABEL_OPTIONS: i0.InjectionToken<InsLabelOptions>;
+declare function insLabelOptionsProvider(options: Partial<InsLabelOptions>): Provider;
+
+declare class InsLink {
+    protected readonly nothing: undefined;
+    pseudo: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsLink, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsLink, "a[insLink], button[insLink]", never, { "pseudo": { "alias": "pseudo"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsWithAppearance; inputs: {}; outputs: {}; }]>;
+}
+
+interface InsLinkOptions extends InsAppearanceOptions {
+    readonly pseudo: boolean;
+}
+declare const INS_LINK_DEFAULT_OPTIONS: InsLinkOptions;
+declare const INS_LINK_OPTIONS: i0.InjectionToken<InsLinkOptions>;
+declare function insLinkOptionsProvider(options: Partial<InsLinkOptions>): FactoryProvider;
+
+declare class InsLoader {
+    private readonly options;
+    size: i0.InputSignal<"s" | "m" | "l" | "xs">;
+    inheritColor: i0.InputSignal<boolean>;
+    overlay: i0.InputSignal<boolean>;
+    textContent: i0.InputSignal<PolymorpheusContent>;
+    protected hasOverlay: i0.Signal<boolean>;
+    loading: i0.InputSignal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsLoader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsLoader, "ins-loader", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "inheritColor": { "alias": "inheritColor"; "required": false; "isSignal": true; }; "overlay": { "alias": "overlay"; "required": false; "isSignal": true; }; "textContent": { "alias": "textContent"; "required": false; "isSignal": true; }; "loading": { "alias": "showLoader"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface InsLoaderOptions {
+    readonly inheritColor: boolean;
+    readonly overlay: boolean;
+    readonly size: 's' | 'm' | 'l';
+}
+/** Default values for the loader options. */
+declare const INS_LOADER_DEFAULT_OPTIONS: InsLoaderOptions;
+/**
+ * Default parameters for loader component
+ */
+declare const INS_LOADER_OPTIONS: i0.InjectionToken<InsLoaderOptions>;
+declare function insLoaderOptionsProvider(options: Partial<InsLoaderOptions>): Provider;
+
+declare class InsNotification {
+    private readonly options;
+    protected readonly nothing: undefined;
+    protected readonly icons: InsIcons;
+    appearance: i0.InputSignal<(Record<never, never> & string) | "accent" | "action-destructive" | "action-grayscale" | "action" | "flat-destructive" | "flat-grayscale" | "flat" | "glass" | "icon" | "info" | "negative" | "neutral" | "outline-destructive" | "outline-grayscale" | "outline" | "positive" | "primary-destructive" | "primary-grayscale" | "primary" | "secondary-destructive" | "secondary-grayscale" | "secondary" | "textfield">;
+    icon: i0.InputSignal<string | InsStringHandler<string>>;
+    size: i0.InputSignal<"s" | "m" | "l">;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsNotification, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsNotification, "ins-notification,[insNotification]", never, { "appearance": { "alias": "appearance"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsWithIcons; inputs: {}; outputs: {}; }, { directive: typeof InsWithAppearance; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsPagination {
+    private readonly els;
+    private readonly el;
+    protected readonly textsSignal: i0.Signal<readonly [previous_page: string, next_page: string] | readonly ["", ""]>;
+    protected readonly icons: _liuk123_insui.InsSpinIcons;
+    length: i0.InputSignal<number>;
+    focusable: i0.InputSignal<boolean>;
+    size: i0.InputSignal<"s" | "m" | "l">;
+    readonly disabled: i0.InputSignal<boolean>;
+    activePadding: i0.InputSignal<number>;
+    sidePadding: i0.InputSignal<number>;
+    content: i0.InputSignal<PolymorpheusContent<InsContext<number>>>;
+    /**
+      * Max number of elements in half (not counting the middle one).
+      */
+    private maxHalfLength;
+    /**
+      * Max number of elements
+      */
+    private maxElementsLength;
+    /**
+      * Is there '...' anywhere
+      */
+    private itemsFit;
+    protected elementsLength: i0.Signal<number>;
+    protected elementArr: i0.Signal<any[]>;
+    private lastElementIndex;
+    private lastIndex;
+    index: i0.ModelSignal<number>;
+    /**
+       * Get index by element index
+       * @param elementIndex
+       * @returns index or null (for '…')
+       */
+    protected getItemIndexByElementIndex(elementIndex: number): number | null;
+    /**
+     * Are there collapsed items at that index
+     * @param index
+     * @returns there are collapsed items
+     */
+    private hasCollapsedItems;
+    arrowIsDisabledLeft: i0.Signal<boolean>;
+    arrowIsDisabledRight: i0.Signal<boolean>;
+    protected elementIsFocusable(index: number): boolean;
+    private updateIndex;
+    protected onElementClick(index: number): void;
+    protected onElementKeyDownArrowLeft(element: HTMLElement): void;
+    protected onElementKeyDownArrowRight(element: HTMLElement): void;
+    protected onArrowClick(direction: 'left' | 'right'): void;
+    private tryChangeTo;
+    private focusActive;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPagination, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsPagination, "ins-pagination", never, { "length": { "alias": "length"; "required": false; "isSignal": true; }; "focusable": { "alias": "focusable"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "activePadding": { "alias": "activePadding"; "required": false; "isSignal": true; }; "sidePadding": { "alias": "sidePadding"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; "index": { "alias": "index"; "required": false; "isSignal": true; }; }, { "index": "indexChange"; }, never, never, true, never>;
+}
+
+declare class InsPopup implements OnDestroy {
+    private readonly template;
+    private readonly service;
+    private viewRef?;
+    set insPopup(show: boolean);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPopup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsPopup, "ng-template[insPopup]", never, { "insPopup": { "alias": "insPopup"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsPopupService extends InsPortalService {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPopupService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsPopupService>;
+}
+
+declare class InsPopups extends InsPortals {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsPopups, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsPopups, "ins-popups", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class InsRadioComponent implements DoCheck, OnInit {
+    private readonly appearance;
+    private readonly options;
+    private readonly el;
+    private readonly destroyRef;
+    private readonly cdr;
+    protected readonly control: NgControl;
+    size: 's' | 'm' | 'l';
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsRadioComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsRadioComponent, "input[type=\"radio\"][insRadio]", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsAppearance; inputs: { "insAppearanceState": "insAppearanceState"; "insAppearanceFocus": "insAppearanceFocus"; "insAppearanceMode": "insAppearanceMode"; }; outputs: {}; }, { directive: typeof InsNativeValidator; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsRadioDirective<T> {
+    identityMatcher: InsIdentityMatcher<T>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsRadioDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsRadioDirective<any>, "input[type=\"radio\"][insRadio][identityMatcher]", never, { "identityMatcher": { "alias": "identityMatcher"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const InsRadio: readonly [typeof InsRadioComponent, typeof InsRadioDirective];
+
+interface InsRadioOptions {
+    readonly appearance: InsStringHandler<HTMLInputElement> | string;
+    readonly size: 's' | 'm' | 'l';
+}
+declare const INS_RADIO_DEFAULT_OPTIONS: InsRadioOptions;
+declare const INS_RADIO_OPTIONS: i0.InjectionToken<InsRadioOptions>;
+declare function insRadioOptionsProvider(options: Partial<InsRadioOptions>): Provider;
+
+declare class InsRoot {
+    private readonly doc;
+    private readonly el;
+    private readonly child;
+    protected readonly reducedMotion: i0.WritableSignal<string>;
+    protected readonly isMobileRes: i0.Signal<boolean>;
+    protected readonly top: i0.WritableSignal<boolean>;
+    protected get parent(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsRoot, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsRoot, "ins-root", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class InsTextFieldSingleDataDirective<T> extends Observable<T[]> {
+    private _data$;
+    data$: Observable<T[]>;
+    set _data(val: T[] | null);
+    getValue: null | Function;
+    identityMatcher: Function;
+    value$: Observable<T | null>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextFieldSingleDataDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTextFieldSingleDataDirective<any>, "[insTextFieldSingleData]", never, { "_data": { "alias": "insTextFieldSingleData"; "required": false; }; "getValue": { "alias": "getValue"; "required": false; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsSelectComponent<T> implements ControlValueAccessor, Validator, InsTextFieldAccessor<T>, OnInit {
+    protected readonly optionsDataDirective: InsTextFieldSingleDataDirective<any>;
+    protected readonly destroyRef: DestroyRef;
+    value: i0.WritableSignal<T>;
+    controlValue$: Subject<T>;
+    writeValue$: Subject<T>;
+    readOnly: i0.InputSignal<boolean>;
+    disabled: i0.InputSignal<boolean>;
+    placeholder: i0.InputSignal<string>;
+    id: string;
+    private propageteChange;
+    writeValue(data: T): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    validate(): any;
+    ngOnInit(): void;
+    mapOptionsToValues: ([dataValues, optionsArray]: [T, T[]]) => T;
+    setFocused(event: MouseEvent): void;
+    setValue(data: T | null): void;
+    getValue(): any;
+    clearValue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsSelectComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsSelectComponent<any>, "ins-select", never, { "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const INS_TAB_ACTIVATE = "ins-tab-activate";
+declare class InsTab implements OnDestroy {
+    readonly el: HTMLElement;
+    private readonly rla;
+    protected readonly sub: rxjs.Subscription;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTab, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTab, "a[insTab]:not([routerLink]), a[insTab][routerLink][routerLinkActive], button[insTab]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsTabsStyles {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTabsStyles, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTabsStyles, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare class InsTabsDirective {
+    private readonly el;
+    protected nothing: undefined;
+    size: i0.InputSignal<"s" | "m" | "l">;
+    activeItemIndex: i0.ModelSignal<number>;
+    tabs: i0.Signal<readonly InsTab[]>;
+    tabElements: i0.Signal<HTMLElement[]>;
+    activeElement: i0.Signal<HTMLElement>;
+    constructor();
+    onActivate(event: Event, element: HTMLElement): void;
+    moveFocus(current: HTMLElement, step: number): void;
+    private scrollTo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTabsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTabsDirective, never, never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "activeItemIndex": { "alias": "activeItemIndex"; "required": false; "isSignal": true; }; }, { "activeItemIndex": "activeItemIndexChange"; }, ["tabs"], never, true, never>;
+}
+
+declare class InsTabsHorizontal {
+    private readonly tabs;
+    protected onKeyDownArrow(current: HTMLElement, step: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTabsHorizontal, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTabsHorizontal, "ins-tabs:not([vertical]), nav[insTabs]:not([vertical])", never, {}, {}, never, never, true, [{ directive: typeof InsTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
+}
+
+declare class InsTabsVertical {
+    private readonly tabs;
+    vertical: i0.InputSignal<InsHorizontalDirection>;
+    protected onKeyDownArrow(current: HTMLElement, step: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTabsVertical, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTabsVertical, "ins-tabs[vertical], nav[insTabs][vertical]", never, { "vertical": { "alias": "vertical"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsTabsDirective; inputs: { "activeItemIndex": "activeItemIndex"; "size": "size"; }; outputs: { "activeItemIndexChange": "activeItemIndexChange"; }; }]>;
+}
+
+declare class InsTabsWithMore implements AfterViewInit, OnInit {
+    private moreButton;
+    private readonly doc;
+    private readonly el;
+    protected readonly moreWord: i0.Signal<string>;
+    protected readonly options: _liuk123_insui.InsTabsOptions;
+    private readonly injector;
+    tabsView: ElementRef;
+    protected moreEl: i0.Signal<any>;
+    protected readonly items: i0.Signal<readonly TemplateRef<any>[]>;
+    activeItemIndex: i0.ModelSignal<number>;
+    protected size: i0.InputSignal<"s" | "m" | "l">;
+    protected readonly moreContent: i0.InputSignal<PolymorpheusContent>;
+    itemsLimit: i0.InputSignal<number>;
+    private margin;
+    private refreshIndex$;
+    protected open: i0.ModelSignal<boolean>;
+    refresh$: rxjs.Observable<void | readonly MutationRecord[] | readonly ResizeObserverEntry[]>;
+    constructor();
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    private tabsContent;
+    private tabs;
+    protected lastVisibleIndex: i0.Signal<number>;
+    private maxIndex;
+    private getMaxIndex;
+    insToInt(bool: boolean): 0 | 1;
+    protected isMoreActive: i0.Signal<boolean>;
+    protected isMoreAlone: i0.Signal<boolean>;
+    protected isMoreVisible: i0.Signal<boolean>;
+    protected get isMoreFocusable(): boolean;
+    private focusMore;
+    protected onClick(index: number): void;
+    protected onArrowLeft(): void;
+    protected onWrapperArrow(event: Event, wrapper: HTMLElement, previous: boolean): void;
+    protected onKeyDownArrow(current: any, step: number): void;
+    onActivate(event: Event): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTabsWithMore, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTabsWithMore, "ins-tabs-with-more", never, { "activeItemIndex": { "alias": "activeItemIndex"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "moreContent": { "alias": "moreContent"; "required": false; "isSignal": true; }; "itemsLimit": { "alias": "itemsLimit"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; }, { "activeItemIndex": "activeItemIndexChange"; "open": "openChange"; }, ["items", "tabsContent"], never, true, never>;
+}
+
+declare const InsTabs: readonly [typeof InsTab, typeof InsTabsDirective, typeof InsTabsHorizontal, typeof InsTabsVertical, typeof InsTabsWithMore];
+
+interface InsTabsOptions {
+    readonly exposeActive: boolean;
+    readonly itemsLimit: number;
+    readonly minMoreWidth: number;
+    readonly underline: boolean | string;
+    readonly size: 's' | 'm' | 'l';
+}
+declare const INS_TABS_DEFAULT_OPTIONS: InsTabsOptions;
+/**
+ * Default parameters for Tabs component
+ */
+declare const INS_TABS_OPTIONS: InjectionToken<InsTabsOptions>;
+declare function insTabsOptionsProvider(options: Partial<InsTabsOptions>): Provider;
+
+declare class InsTextfieldComponent<T> implements InsDataListHost<T> {
+    protected readonly controller: i0.Signal<InsTextFieldAccessor<T>>;
+    readonly focused: i0.Signal<boolean>;
+    readonly options: _liuk123_insui.InsTextfieldOptions;
+    readonly icons: _liuk123_insui.InsCommonIcons;
+    readonly clear: i0.Signal<string>;
+    cleaner: i0.WritableSignal<boolean>;
+    size: InputSignal<"s" | "m" | "l" | "xs">;
+    handleOption(option: T): void;
+    side: i0.WritableSignal<string>;
+    onResize({ contentRect }: any | ResizeObserverEntry): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextfieldComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTextfieldComponent<any>, "ins-textfield", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, ["controller"], ["select,input,textarea,ins-input-tag", "*", "ins-icon"], true, [{ directive: typeof InsWithIcons; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsTextfieldDropdownDirective {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextfieldDropdownDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTextfieldDropdownDirective, "ng-template[insTextfieldDropdown]", never, {}, {}, never, never, true, never>;
+}
+declare class InsWithTextfieldDropdown {
+    private readonly dropdown;
+    private readonly textfield;
+    protected temp: i0.Signal<TemplateRef<any>>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsWithTextfieldDropdown, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsWithTextfieldDropdown, "[insWithTextfieldDropdown]", never, {}, {}, ["temp"], never, true, [{ directive: typeof InsWithDropdownOpen; inputs: {}; outputs: {}; }, { directive: typeof InsDropdownDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsTextFieldController<T> implements InsTextFieldAccessor<T> {
+    readonly el: HTMLInputElement;
+    protected readonly autoId: string;
+    stringify: StringConstructor;
+    id: string;
+    setValue(value: T | null): void;
+    getValue(): any;
+    clearValue(): void;
+    setFocused(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextFieldController<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTextFieldController<any>, "[insTextFieldController]", never, { "stringify": { "alias": "stringify"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsTextfieldDirective; inputs: { "invalid": "invalid"; "focused": "focused"; "readOnly": "readOnly"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+
+declare class InsTextFieldDataDirective<T> extends Observable<T[]> {
+    private _data$;
+    data$: Observable<T[]>;
+    set _data(val: T[] | null);
+    getValue: null | Function;
+    identityMatcher: Function;
+    stringify: Function;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextFieldDataDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTextFieldDataDirective<any>, "[insTextFieldData]", never, { "_data": { "alias": "insTextFieldData"; "required": false; }; "getValue": { "alias": "getValue"; "required": false; }; "identityMatcher": { "alias": "identityMatcher"; "required": false; }; "stringify": { "alias": "stringify"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const InsTextfield: readonly [typeof InsLabel, typeof InsTextfieldComponent, typeof InsTextfieldDirective, typeof InsTextFieldController, typeof InsTextfieldDropdownDirective, typeof InsTextFieldDataDirective, typeof InsWithTextfieldDropdown, typeof InsTextFieldSingleDataDirective];
+
+declare class InsTreeChildren<T> {
+    childrenHandler: i0.InputSignal<InsHandler<T, readonly T[]>>;
+    static defaultHandler<G>(item: G): readonly G[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTreeChildren<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTreeChildren<any>, "ins-tree[childrenHandler]", never, { "childrenHandler": { "alias": "childrenHandler"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface InsTreeItemContext<T> extends InsContext<InsTreeItem<T>> {
+    readonly template: TemplateRef<Record<string, unknown>>;
+}
+interface InsTreeContext<T> extends InsContext<T> {
+    readonly node: InsTreeItem<T>;
+}
+interface InsTreeController<T> {
+    isExpanded(item: InsTreeItem<T>): boolean;
+    toggle(item: InsTreeItem<T>): void;
+}
+interface InsTreeAccessor<T> {
+    register(item: InsTreeItem<T>, value: T): void;
+    unregister(item: InsTreeItem<T>): void;
+}
+interface InsTreeLoader<T> {
+    hasChildren(item: T): boolean;
+    loadChildren(item: T): Observable<T[]>;
+}
+
+declare class InsTreeItem<T> implements DoCheck, OnDestroy {
+    protected readonly nested: i0.Signal<readonly QueryList<unknown>[]>;
+    private readonly change$;
+    protected readonly directive: InsTreeChildren<T>;
+    value: i0.InputSignal<T>;
+    trackBy: TrackByFunction<T>;
+    content: PolymorpheusContent<InsTreeContext<T>>;
+    protected handler: i0.Signal<_liuk123_insui.InsHandler<T, readonly T[]>>;
+    protected readonly children: i0.Signal<readonly T[]>;
+    private readonly controller;
+    private readonly accessor;
+    protected readonly level: number;
+    readonly expanded: i0.Signal<boolean>;
+    isExpandable: i0.Signal<boolean>;
+    get isExpanded(): boolean;
+    constructor();
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    protected readonly icons: _liuk123_insui.InsCommonIcons;
+    protected readonly more: i0.Signal<string>;
+    protected onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTreeItem<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTreeItem<any>, "ins-tree", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": false; }; "content": { "alias": "content"; "required": false; }; }, {}, ["nested"], ["*", "ins-tree"], true, never>;
+}
+
+declare class InsTreeControllerDirective<T> implements InsTreeController<T>, InsTreeAccessor<T> {
+    protected readonly items: Map<InsTreeItem<T>, T>;
+    fallback: boolean;
+    map: Map<T, boolean>;
+    register(item: InsTreeItem<T>, value: T): void;
+    unregister(item: InsTreeItem<T>): void;
+    isExpanded(item: InsTreeItem<T>): boolean;
+    toggle(item: InsTreeItem<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTreeControllerDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTreeControllerDirective<any>, "[insTreeController][map]", ["insTreeController"], { "fallback": { "alias": "insTreeController"; "required": false; }; "map": { "alias": "map"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class InsTreeItemController<T> implements InsTreeController<T> {
+    private readonly map;
+    fallback: boolean;
+    isExpanded(item: InsTreeItem<T>): boolean;
+    toggle(item: InsTreeItem<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTreeItemController<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTreeItemController<any>, "[insTreeController]:not([map])", ["insTreeController"], { "fallback": { "alias": "insTreeController"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const INS_DEFAULT_TREE_CONTROLLER: InsTreeController<any>;
+
+declare class InsTreeService<T> {
+    private readonly loading;
+    private readonly start;
+    private readonly loader;
+    private readonly map;
+    private readonly load$;
+    readonly data$: rxjs.Observable<T>;
+    getChildren(item: T): readonly T[];
+    loadChildren(item: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTreeService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<InsTreeService<any>>;
+}
+
+/**
+ * Controller for tracking value - InsTreeItemComponent pairs
+ */
+declare const INS_TREE_ACCESSOR: InjectionToken<InsTreeAccessor<unknown>>;
+/**
+ * Controller for expanding the tree
+ */
+declare const INS_TREE_CONTROLLER: InjectionToken<_liuk123_insui.InsTreeController<any>>;
+/**
+ * A node of a tree view
+ */
+declare const INS_TREE_NODE: InjectionToken<unknown>;
+/**
+ * A tree node placeholder for loading
+ */
+declare const INS_TREE_LOADING: InjectionToken<{}>;
+/**
+ * A tree node starting point
+ */
+declare const INS_TREE_START: InjectionToken<unknown>;
+/**
+ * A service to load tree progressively
+ */
+declare const INS_TREE_LOADER: InjectionToken<InsTreeLoader<unknown>>;
+/**
+ * Content for a tree item
+ */
+/**
+ * Nesting level of current TreeView node
+ */
+declare const INS_TREE_LEVEL: InjectionToken<number>;
+
+declare const InsTree: readonly [typeof InsTreeItem, typeof InsTreeChildren, typeof InsTreeItemController, typeof InsTreeControllerDirective];
+
+declare class InsTitle {
+    protected readonly nothing: undefined;
+    size: i0.InputSignalWithTransform<"s" | "m" | "l" | "xs" | "xl" | "xxl", "" | "s" | "m" | "l" | "xs" | "xl" | "xxl">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTitle, "[insTitle]", never, { "size": { "alias": "insTitle"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsTextarea implements AfterViewInit {
+    private readonly template?;
+    private readonly vcr;
+    protected readonly el: HTMLTextAreaElement;
+    private readonly options;
+    min: i0.InputSignal<number>;
+    max: i0.InputSignal<number>;
+    content: i0.InputSignal<_liuk123_insui.PolymorpheusContent<_liuk123_insui.InsContext<string>>>;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextarea, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTextarea, "textarea[insTextarea]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "content": { "alias": "content"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof InsTextFieldController; inputs: { "stringify": "stringify"; }; outputs: {}; }]>;
+}
+
+interface InsTextareaOptions {
+    min: number;
+    max: number;
+    content: PolymorpheusContent<InsContext<string>>;
+}
+declare const INS_TEXTAREA_DEFAULT_OPTIONS: InsTextareaOptions;
+declare const INS_TEXTAREA_OPTIONS: i0.InjectionToken<InsTextareaOptions>;
+declare function insTextareaOptionsProvider(options: Partial<InsTextareaOptions>): FactoryProvider;
+
+declare class InsTextareaLimitComponent {
+    protected readonly limit: i0.InputSignal<number>;
+    protected readonly context: InsContext<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextareaLimitComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTextareaLimitComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare class InsTextareaCounterComponent {
+    readonly limit: i0.WritableSignal<number>;
+    readonly length: i0.WritableSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextareaCounterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTextareaCounterComponent, "ng-component", never, {}, {}, never, never, true, never>;
+}
+declare class InsTextareaLimit implements Validator, DoCheck {
+    private readonly textfield;
+    private readonly ref;
+    readonly size: "s" | "m" | "l" | "xs";
+    readonly limit: i0.InputSignal<number>;
+    ngDoCheck(): void;
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTextareaLimit, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTextareaLimit, "textarea[insLimit]", never, { "limit": { "alias": "insLimit"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare const NG_EVENT_PLUGINS: Provider[];
+
+declare class OptionsEventPlugin extends EventManagerPlugin {
+    readonly modifier = "capture.once.passive";
+    constructor();
+    supports(event: string): boolean;
+    addEventListener(element: HTMLElement, event: string, handler: EventListener): Function;
+    protected unwrap(event: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OptionsEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OptionsEventPlugin>;
+}
+
+declare class PreventEventPlugin extends EventManagerPlugin {
+    readonly modifier = ".prevent";
+    constructor();
+    supports(event: string): boolean;
+    addEventListener(element: HTMLElement, event: string, handler: Function): Function;
+    protected unwrap(event: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PreventEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PreventEventPlugin>;
+}
+
+declare class SelfEventPlugin extends EventManagerPlugin {
+    readonly modifier = ".self";
+    constructor();
+    supports(event: string): boolean;
+    addEventListener(element: HTMLElement, event: string, handler: Function): Function;
+    protected unwrap(event: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelfEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SelfEventPlugin>;
+}
+
+declare class SilentEventPlugin extends EventManagerPlugin {
+    readonly modifier = ".zoneless";
+    static ngZone?: NgZone;
+    constructor();
+    supports(event: string): boolean;
+    addEventListener(element: HTMLElement, event: string, handler: Function): Function;
+    protected unwrap(event: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SilentEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SilentEventPlugin>;
+}
+
+declare class StopEventPlugin extends EventManagerPlugin {
+    readonly modifier = ".stop";
+    constructor();
+    supports(event: string): boolean;
+    addEventListener(element: HTMLElement, event: string, handler: Function): Function;
+    protected unwrap(event: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StopEventPlugin, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StopEventPlugin>;
+}
+
+type InsLanguageName = 'belarusian' | 'chinese' | 'dutch' | 'english' | 'french' | 'german' | 'hebrew' | 'italian' | 'japan' | 'kazakh' | 'korean' | 'malay' | 'polish' | 'portuguese' | 'russian' | 'spanish' | 'turkish' | 'ukrainian' | 'vietnamese' | (Record<never, never> & string);
+
+interface InsLanguageCore {
+    close: string;
+    clear: string;
+    defaultErrorMessage: 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
+    ];
+    nothingFoundMessage: string;
+    shortWeekDays: [
+        Monday: string,
+        Tuesday: string,
+        Wednesday: string,
+        Thursday: string,
+        Friday: string,
+        Saturday: string,
+        Sunday: string
+    ];
+    spinTexts: [previous: string, next: string];
+    more: string;
+    pagination: readonly [previous_page: string, next_page: string];
+    cancel: string;
+    copyTexts: [copy: string, copied: string];
+    hide: string;
+    showAll: string;
+    fileTexts: {
+        loadingError: string;
+        preview: string;
+        remove: string;
+    };
+    digitalInformationUnits: [
+        short_byte: string,
+        short_kilobyte: string,
+        short_megabyte: string
+    ];
+    confirm: {
+        no: string;
+        yes: string;
+    };
+}
+interface InsLanguageKit {
+    cancel: string;
+    copyTexts: [copy: string, copied: string];
+    countTexts: [plus: string, minus: string];
+    dateTexts: {
+        DMY: string;
+        MDY: string;
+        YMD: string;
+    };
+    digitalInformationUnits: [
+        short_byte: string,
+        short_kilobyte: string,
+        short_megabyte: string
+    ];
+    done: string;
+    fileTexts: {
+        loadingError: string;
+        preview: string;
+        remove: string;
+    };
+    hide: string;
+    inputFileTexts: {
+        defaultLabelMultiple: string;
+        defaultLabelSingle: string;
+        defaultLinkMultiple: string;
+        defaultLinkSingle: string;
+        drop: string;
+        dropMultiple: string;
+        formatRejectionReason: string;
+        maxSizeRejectionReason: string;
+    };
+    mobileCalendarTexts: [choose_day: string, choose_range: string, choose_days: string];
+    more: string;
+    multiSelectTexts: {
+        all: string;
+        none: string;
+    };
+    otherDate: string;
+    pagination: [previous_page: string, next_page: string];
+    passwordTexts: [show_password: string, hide_password: string];
+    confirm: {
+        no: string;
+        yes: string;
+    };
+    range: [from: string, to: string];
+    shortCalendarMonths: [
+        January: string,
+        February: string,
+        March: string,
+        April: string,
+        May: string,
+        June: string,
+        July: string,
+        August: string,
+        September: string,
+        October: string,
+        November: string,
+        December: string
+    ];
+    showAll: string;
+    time: {
+        'HH:MM': string;
+        'HH:MM:SS': string;
+        'HH:MM:SS.MSS': string;
+    };
+    previewTexts: {
+        rotate: string;
+    };
+    zoomTexts: {
+        zoomIn: string;
+        zoomOut: string;
+        reset: string;
+    };
+}
+interface InsLanguageMeta {
+    name: InsLanguageName;
+}
+interface InsLanguage extends InsLanguageCore, InsLanguageMeta {
+}
+
+declare const INS_CHINESE_LANGUAGE: InsLanguage;
+
+declare const INS_DEFAULT_LANGUAGE: InjectionToken<InsLanguage>;
+/**
+ * Language for libraries i18n
+ */
+declare const INS_LANGUAGE: InjectionToken<Observable<InsLanguage>>;
+
+type InsCountryIsoCode = 'AC' | 'AD' | 'AE' | 'AF' | 'AG' | 'AI' | 'AL' | 'AM' | 'AO' | 'AR' | 'AS' | 'AT' | 'AU' | 'AW' | 'AX' | 'AZ' | 'BA' | 'BB' | 'BD' | 'BE' | 'BF' | 'BG' | 'BH' | 'BI' | 'BJ' | 'BL' | 'BM' | 'BN' | 'BO' | 'BQ' | 'BR' | 'BS' | 'BT' | 'BW' | 'BY' | 'BZ' | 'CA' | 'CC' | 'CD' | 'CF' | 'CG' | 'CH' | 'CI' | 'CK' | 'CL' | 'CM' | 'CN' | 'CO' | 'CR' | 'CU' | 'CV' | 'CW' | 'CX' | 'CY' | 'CZ' | 'DE' | 'DJ' | 'DK' | 'DM' | 'DO' | 'DZ' | 'EC' | 'EE' | 'EG' | 'EH' | 'ER' | 'ES' | 'ET' | 'FI' | 'FJ' | 'FK' | 'FM' | 'FO' | 'FR' | 'GA' | 'GB' | 'GD' | 'GE' | 'GF' | 'GG' | 'GH' | 'GI' | 'GL' | 'GM' | 'GN' | 'GP' | 'GQ' | 'GR' | 'GT' | 'GU' | 'GW' | 'GY' | 'HK' | 'HN' | 'HR' | 'HT' | 'HU' | 'ID' | 'IE' | 'IL' | 'IM' | 'IN' | 'IO' | 'IQ' | 'IR' | 'IS' | 'IT' | 'JE' | 'JM' | 'JO' | 'JP' | 'KE' | 'KG' | 'KH' | 'KI' | 'KM' | 'KN' | 'KP' | 'KR' | 'KW' | 'KY' | 'KZ' | 'LA' | 'LB' | 'LC' | 'LI' | 'LK' | 'LR' | 'LS' | 'LT' | 'LU' | 'LV' | 'LY' | 'MA' | 'MC' | 'MD' | 'ME' | 'MF' | 'MG' | 'MH' | 'MK' | 'ML' | 'MM' | 'MN' | 'MO' | 'MP' | 'MQ' | 'MR' | 'MS' | 'MT' | 'MU' | 'MV' | 'MW' | 'MX' | 'MY' | 'MZ' | 'NA' | 'NC' | 'NE' | 'NF' | 'NG' | 'NI' | 'NL' | 'NO' | 'NP' | 'NR' | 'NU' | 'NZ' | 'OM' | 'PA' | 'PE' | 'PF' | 'PG' | 'PH' | 'PK' | 'PL' | 'PM' | 'PR' | 'PS' | 'PT' | 'PW' | 'PY' | 'QA' | 'RE' | 'RO' | 'RS' | 'RU' | 'RW' | 'SA' | 'SB' | 'SC' | 'SD' | 'SE' | 'SG' | 'SH' | 'SI' | 'SJ' | 'SK' | 'SL' | 'SM' | 'SN' | 'SO' | 'SR' | 'SS' | 'ST' | 'SV' | 'SX' | 'SY' | 'SZ' | 'TA' | 'TC' | 'TD' | 'TG' | 'TH' | 'TJ' | 'TK' | 'TL' | 'TM' | 'TN' | 'TO' | 'TR' | 'TT' | 'TV' | 'TW' | 'TZ' | 'UA' | 'UG' | 'US' | 'UY' | 'UZ' | 'VA' | 'VC' | 'VE' | 'VG' | 'VI' | 'VN' | 'VU' | 'WF' | 'WS' | 'XK' | 'YE' | 'YT' | 'ZA' | 'ZM' | 'ZW';
+
+declare function insExtractI18n<K extends keyof InsLanguage>(key: K): () => Observable<InsLanguage[K]>;
+
+declare class InsCardLarge {
+    protected readonly nothing: undefined;
+    space: i0.InputSignalWithTransform<"normal" | "compact" | "large", "" | "normal" | "compact" | "large">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsCardLarge, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsCardLarge, "[insCardLarge]", never, { "space": { "alias": "insCardLarge"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsCell {
+    protected readonly nothing: undefined;
+    size: i0.InputSignalWithTransform<"s" | "m" | "l", "" | "s" | "m" | "l">;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsCell, "[insCell]:not(ng-template)", never, { "size": { "alias": "insCell"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsHeader {
+    protected readonly nothing: undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsHeader, "[insHeader]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsMapperPipe implements PipeTransform {
+    /**
+     * Maps object to an arbitrary result through a mapper function
+     *
+     * @param value an item to transform
+     * @param mapper a mapping function
+     * @param args arbitrary number of additional arguments
+     */
+    transform<T extends unknown[], U, G>(value: U, mapper: InsMapper<[U, ...T], G>, ...args: T): G;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsMapperPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<InsMapperPipe, "insMapper", true>;
+}
+
+/**
+ * Active element on the document for ActiveZone
+ */
+declare const INS_ACTIVE_ELEMENT: i0.InjectionToken<Observable<EventTarget>>;
+
+interface InsCommonIcons {
+    readonly check: string;
+    readonly close: string;
+    readonly error: string;
+    readonly more: string;
+    readonly search: string;
+    readonly ellipsis: string;
+}
+declare const INS_COMMON_ICONS: i0.InjectionToken<InsCommonIcons>;
+declare function commonIconsProvider(icons: Partial<InsCommonIcons>): Provider;
+
+declare const IS_IOS: i0.InjectionToken<boolean>;
+
+/**
+ * Localized months names
+ */
+/**
+ * i18n 'close' word
+ */
+declare const INS_CLOSE_WORD: i0.InjectionToken<rxjs.Observable<string>>;
+/**
+ * i18n 'clear' word
+ */
+declare const INS_CLEAR_WORD: i0.InjectionToken<rxjs.Observable<string>>;
+/**
+ * i18n 'Nothing found' message
+ */
+declare const INS_NOTHING_FOUND_MESSAGE: i0.InjectionToken<rxjs.Observable<string>>;
+/**
+ * i18n of error message
+ */
+declare const INS_DEFAULT_ERROR_MESSAGE: i0.InjectionToken<rxjs.Observable<string>>;
+/**
+ * spin i18n texts
+ */
+/**
+ * calendars i18n texts
+ */
+declare const INS_MORE_WORD: i0.InjectionToken<rxjs.Observable<string>>;
+declare const INS_PAGINATION_TEXTS: i0.InjectionToken<rxjs.Observable<readonly [previous_page: string, next_page: string]>>;
+
+declare const REDUCED_MOTION: i0.InjectionToken<boolean>;
+
+declare const INS_REMOVED_ELEMENT: InjectionToken<rxjs.Observable<any>>;
+
+interface InsSpinIcons {
+    readonly decrement: string;
+    readonly increment: string;
+}
+declare const INS_SPIN_ICONS: i0.InjectionToken<InsSpinIcons>;
+
+/**
+ * Validation errors
+ */
+declare const INS_VALIDATION_ERRORS: i0.InjectionToken<Record<string, PolymorpheusContent | Observable<PolymorpheusContent>>>;
+
+/**
+ * Viewport accessor
+ */
+declare const INS_VIEWPORT: i0.InjectionToken<InsRectAccessor>;
+declare function insAsViewport(accessor: Type<InsRectAccessor>): Provider;
+
+/**
+ * A stream of possible selection changes
+ */
+declare const INS_SELECTION_STREAM: InjectionToken<Observable<unknown>>;
+
+declare const WINDOW: InjectionToken<Window>;
+
+declare const ANIMATION_FRAME: InjectionToken<Observable<number>>;
+
+/**
+ * 存储接口，模拟localStorage API
+ */
+interface Storage {
+    readonly length: number;
+    clear(): void;
+    getItem(key: string): string | null;
+    key(index: number): string | null;
+    removeItem(key: string): void;
+    setItem(key: string, value: string): void;
+}
+declare const LOCAL_STORAGE: InjectionToken<Storage>;
+
+declare class MutationObserverService extends Observable<readonly MutationRecord[]> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutationObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MutationObserverService>;
+}
+
+declare const SafeObserver: {
+    new (callback: MutationCallback): MutationObserver;
+    prototype: MutationObserver;
+};
+declare const MUTATION_OBSERVER_INIT: InjectionToken<MutationObserverInit>;
+declare function provideMutationObserverInit(useValue: MutationObserverInit): Provider;
+
+declare class MutationObserver$1 extends SafeObserver implements OnDestroy {
+    private readonly nativeElement;
+    private readonly config;
+    attributeFilter: string;
+    attributeOldValue: "";
+    attributes: "";
+    characterData: "";
+    characterDataOldValue: "";
+    childList: "";
+    subtree: "";
+    readonly mutationObserver: EventEmitter<MutationRecord[]>;
+    constructor();
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MutationObserver$1, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<MutationObserver$1, "[mutationObserver]", ["MutationObserver"], { "attributeFilter": { "alias": "attributeFilter"; "required": false; }; "attributeOldValue": { "alias": "attributeOldValue"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "characterData": { "alias": "characterData"; "required": false; }; "characterDataOldValue": { "alias": "characterDataOldValue"; "required": false; }; "childList": { "alias": "childList"; "required": false; }; "subtree": { "alias": "subtree"; "required": false; }; }, { "mutationObserver": "mutationObserver"; }, never, never, true, never>;
+}
+
+declare class ResizeObserverService extends Observable<readonly ResizeObserverEntry[]> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserverService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResizeObserverService>;
+}
+
+declare const RESIZE_OPTION_BOX_DEFAULT = "content-box";
+declare const RESIZE_OPTION_BOX: InjectionToken<ResizeObserverBoxOptions>;
+
+declare class ResizeObserver$1 {
+    protected readonly resizeObserver: ResizeObserverService;
+    box: ResizeObserverBoxOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResizeObserver$1, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ResizeObserver$1, "[resizeObserver]", never, { "resizeBox": { "alias": "box"; "required": false; }; }, { "resizeObserver": "resizeObserver"; }, never, never, true, never>;
+}
+
+declare class InsTableTd {
+    protected readonly textfield: i0.Signal<InsTextfieldComponent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableTd, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTableTd, "th[insTd], td[insTd]", never, {}, {}, ["textfield"], ["*"], true, never>;
+}
+
+declare class InsTableThGroup<T extends Partial<Record<keyof T, any>>> {
+    protected readonly th: i0.Signal<readonly any[]>;
+    protected readonly heads: i0.Signal<readonly any[]>;
+    protected readonly table: any;
+    protected headsSignal: i0.Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableThGroup<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTableThGroup<any>, "tr[insThGroup]", never, {}, {}, ["th", "heads"], ["*"], true, never>;
+}
+
+declare class InsTableTh<T extends Partial<Record<keyof T, any>>> {
+    private readonly options;
+    protected width: i0.WritableSignal<number>;
+    protected onResized(width: number): void;
+    resizable: i0.InputSignal<boolean>;
+    sticky: i0.InputSignal<boolean>;
+    readonly minWidth: i0.InputSignal<number>;
+    readonly maxWidth: i0.InputSignal<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableTh<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTableTh<any>, "th[insTh]", never, { "resizable": { "alias": "resizable"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; "minWidth": { "alias": "minWidth"; "required": false; "isSignal": true; }; "maxWidth": { "alias": "maxWidth"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class InsTableCell {
+    insCell: i0.InputSignal<string>;
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableCell, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableCell, "ng-template[insCell]", never, { "insCell": { "alias": "insCell"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsStuck {
+    protected readonly stuck: i0.Signal<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsStuck, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsStuck, "ins-stuck:never", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsTableDirective<T extends Partial<Record<keyof T, any>>> implements AfterViewInit {
+    private readonly options;
+    private readonly cdr;
+    protected readonly nothing: undefined;
+    columns: i0.InputSignal<readonly (string | keyof T)[]>;
+    readonly appearance: i0.WritableSignal<string>;
+    readonly size: i0.WritableSignal<"s" | "m" | "l">;
+    readonly cleaner: i0.WritableSignal<boolean>;
+    set sizeSetter(size: 's' | 'm' | 'l');
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableDirective<any>, "table[insTable]", never, { "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "sizeSetter": { "alias": "size"; "required": false; }; }, {}, never, never, true, [{ directive: typeof InsStuck; inputs: {}; outputs: {}; }]>;
+}
+
+declare class InsTableTr<T extends Partial<Record<keyof T, any>>> {
+    private readonly cells;
+    protected readonly items: i0.Signal<Record<string | keyof T, InsTableCell>>;
+    protected readonly table: InsTableDirective<T>;
+    private readonly body;
+    protected readonly item: i0.Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableTr<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTableTr<any>, "tr[insTr]", never, {}, {}, ["cells"], ["*"], true, never>;
+}
+
+declare class InsTableHead<T extends Partial<Record<keyof T, any>>> {
+    insHead: string | keyof T;
+    readonly template: TemplateRef<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableHead<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableHead<any>, "[insHead]", never, { "insHead": { "alias": "insHead"; "required": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsTableResized {
+    private readonly doc;
+    private readonly el;
+    private readonly insResized$;
+    readonly insResized: i0.OutputRef<number>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableResized, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableResized, "[insResized]", never, {}, { "insResized": "insResized"; }, never, never, true, never>;
+}
+
+declare class InsTableTbody<T extends Partial<Record<keyof T, any>>> {
+    readonly rows: i0.Signal<readonly any[]>;
+    data: i0.InputSignal<readonly T[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableTbody<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableTbody<any>, "tbody[insTbody]", never, { "data": { "alias": "data"; "required": false; "isSignal": true; }; }, {}, ["rows"], never, true, never>;
+}
+
+declare class InsTableThead {
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableThead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableThead, "thead[insThead]", never, {}, {}, never, never, true, [{ directive: typeof InsStuck; inputs: {}; outputs: {}; }]>;
+}
+
+declare const InsTable: readonly [typeof InsTableDirective, typeof InsTableTbody, typeof InsTableThGroup, typeof InsTableTh, typeof InsTableTd, typeof InsTableTr, typeof InsTableCell, typeof InsTableHead, typeof InsTableThead, typeof InsTableResized];
+
+interface InsTableOptions {
+    readonly direction: -1 | 1;
+    readonly requiredSort: boolean;
+    readonly open: boolean;
+    readonly resizable: boolean;
+    readonly size: 's' | 'm' | 'l';
+    readonly sortIcons: {
+        readonly asc: string;
+        readonly desc: string;
+        readonly off: string;
+    };
+    readonly sticky: boolean;
+}
+declare const INS_TABLE_DEFAULT_OPTIONS: InsTableOptions;
+declare const INS_TABLE_OPTIONS: i0.InjectionToken<InsTableOptions>;
+declare function insTableOptionsProvider(options: Partial<InsTableOptions>): Provider;
+
+declare class InsTableExpand {
+    private readonly content;
+    private readonly el;
+    private readonly server;
+    protected readonly transitioning: i0.WritableSignal<boolean>;
+    protected readonly contentHeight: i0.Signal<number>;
+    protected readonly visible$: Subject<boolean>;
+    protected readonly sub: rxjs.Subscription;
+    readonly expanded: i0.ModelSignal<boolean>;
+    protected readonly transitioningEffect: i0.EffectRef;
+    toggle(): void;
+    private update;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableExpand, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<InsTableExpand, "ins-table-expand", never, { "expanded": { "alias": "expanded"; "required": false; "isSignal": true; }; }, { "expanded": "expandedChange"; }, never, ["*"], true, [{ directive: typeof InsPresent; inputs: {}; outputs: { "insPresent": "insPresent"; }; }]>;
+}
+
+declare class InsCheckboxRowDirective<T> implements OnInit, OnDestroy {
+    private readonly control;
+    private readonly parent;
+    protected readonly checked: i0.Signal<boolean>;
+    readonly insCheckboxRow: i0.InputSignal<T>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected onChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsCheckboxRowDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsCheckboxRowDirective<any>, "[insCheckbox][insCheckboxRow]", never, { "insCheckboxRow": { "alias": "insCheckboxRow"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class InsTableControlDirective<T> extends InsControl<readonly T[]> {
+    private readonly children;
+    readonly checked: Signal<boolean>;
+    readonly indeterminate: Signal<boolean>;
+    toggleAll(): void;
+    process(checkbox: InsCheckboxRowDirective<T>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsTableControlDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsTableControlDirective<any>, "[insTable][ngModel],[insTable][formControl],[insTable][formControlName]", never, {}, {}, never, never, true, never>;
+}
+
+declare class InsCheckboxTableDirective {
+    private readonly el;
+    private readonly control;
+    protected readonly parent: InsTableControlDirective<any>;
+    protected readonly update: i0.EffectRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<InsCheckboxTableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InsCheckboxTableDirective, "[insCheckbox][insCheckboxTable]", never, {}, {}, never, never, true, never>;
+}
+
+declare const InsTableControl: readonly [typeof InsCheckboxRowDirective, typeof InsCheckboxTableDirective, typeof InsTableControlDirective];
+
+export { ANIMATION_FRAME, EMPTY_ARRAY, EMPTY_CLIENT_RECT, EMPTY_FUNCTION, EMPTY_QUERY, FieldErrorPipe, INS_ACTIVE_ELEMENT, INS_ALERT_CONCURRENCY, INS_ALERT_DEFAULT_OPTIONS, INS_ALERT_OPTIONS, INS_APPEARANCE_DEFAULT_OPTIONS, INS_APPEARANCE_OPTIONS, INS_ASSETS_PATH, INS_AVATAR_DEFAULT_OPTIONS, INS_AVATAR_OPTIONS, INS_BUTTON_DEFAULT_OPTIONS, INS_BUTTON_OPTIONS, INS_CHECKBOX_DEFAULT_OPTIONS, INS_CHECKBOX_OPTIONS, INS_CHEVRON, INS_CHINESE_LANGUAGE, INS_CHIP_DEFAULT_OPTIONS, INS_CHIP_OPTIONS, INS_CLEAR_WORD, INS_CLOSE_WORD, INS_COMMON_ICONS, INS_DATA_LIST_ACCESSOR, INS_DATA_LIST_HOST, INS_DEFAULT_ERROR_MESSAGE, INS_DEFAULT_LANGUAGE, INS_DEFAULT_TREE_CONTROLLER, INS_DIALOG_DEFAULT_OPTIONS, INS_DIALOG_OPTIONS, INS_DROPDOWN_COMPONENT, INS_DROPDOWN_CONTEXT, INS_DROPDOWN_DEFAULT_OPTIONS, INS_DROPDOWN_HOVER_DEFAULT_OPTIONS, INS_DROPDOWN_HOVER_OPTIONS, INS_DROPDOWN_OPTIONS, INS_ENTER, INS_FORM_DEFAULT_OPTIONS, INS_FORM_OPTIONS, INS_GROUP_DEFAULT_OPTIONS, INS_GROUP_OPTIONS, INS_ICON_END, INS_ICON_START, INS_ICON_STARTS, INS_INPUT_TAG_DEFAULT_OPTIONS, INS_INPUT_TAG_OPTIONS, INS_LABEL_DEFAULT_OPTIONS, INS_LABEL_OPTIONS, INS_LANGUAGE, INS_LEAVE, INS_LINK_DEFAULT_OPTIONS, INS_LINK_OPTIONS, INS_LOADER_DEFAULT_OPTIONS, INS_LOADER_OPTIONS, INS_MEDIA, INS_MORE_WORD, INS_NOTHING_FOUND_MESSAGE, INS_NOTIFICATION_DEFAULT_OPTIONS, INS_NOTIFICATION_OPTIONS, INS_PAGINATION_TEXTS, INS_RADIO_DEFAULT_OPTIONS, INS_RADIO_OPTIONS, INS_REMOVED_ELEMENT, INS_SELECTION_STREAM, INS_SPIN_ICONS, INS_SWIPE_OPTIONS, INS_TABLE_DEFAULT_OPTIONS, INS_TABLE_OPTIONS, INS_TABS_DEFAULT_OPTIONS, INS_TABS_OPTIONS, INS_TAB_ACTIVATE, INS_TEXTAREA_DEFAULT_OPTIONS, INS_TEXTAREA_OPTIONS, INS_TEXTFIELD_ACCESSOR, INS_TEXTFIELD_DEFAULT_OPTIONS, INS_TEXTFIELD_OPTIONS, INS_TREE_ACCESSOR, INS_TREE_CONTROLLER, INS_TREE_LEVEL, INS_TREE_LOADER, INS_TREE_LOADING, INS_TREE_NODE, INS_TREE_START, INS_VALIDATION_ERRORS, INS_VIEWPORT, INS_ZOOM_OPTIONS, IS_IOS, InsAccessor, InsAccordion, InsAccordionComponent, InsAccordionDirective, InsActiveZone, InsAlert, InsAlertComponent, InsAlertService, InsAnimated, InsAppearance, InsAvatar, InsBreakpointService, InsButton, InsButtonLoading, InsCardLarge, InsCell, InsCheckbox, InsCheckboxRowDirective, InsCheckboxTableDirective, InsChevron, InsChip, InsCopyProcessor, InsDataList, InsDataListComponent, InsDialog, InsDialogComponent, InsDialogService, InsDriver, InsDriverDirective, InsDropdown, InsDropdownComponent, InsDropdownContent, InsDropdownDirective, InsDropdownDriver, InsDropdownDriverDirective, InsDropdownHover, InsDropdownOpen, InsDropdownOptionsDirective, InsDropdownPosition, InsDropdownPositionSided, InsDropdownSelection, InsError, InsExpand, InsFade, InsFocusTrap, InsForm, InsGroup, InsHeader, InsIcon, InsIcons, InsIdService, InsInputTagComponent, InsItem, InsLabel, InsLink, InsLoader, InsMapperPipe, InsModalComponent, InsModalService, InsNativeValidator, InsNoHostException, InsNotification, InsNotificationDirective, InsNotificationService, InsObscured, InsObscuredService, InsOptGroup, InsOption, InsPagination, InsPopup, InsPopupService, InsPopups, InsPortal, InsPortalDirective, InsPortalService, InsPortals, InsPositionAccessor, InsPositionService, InsPresent, InsRadio, InsRadioComponent, InsRadioDirective, InsRectAccessor, InsResize, InsRoot, InsSelectComponent, InsStuck, InsSwipe, InsSwipeService, InsTab, InsTable, InsTableCell, InsTableControl, InsTableControlDirective, InsTableDirective, InsTableExpand, InsTableHead, InsTableResized, InsTableTbody, InsTableTd, InsTableTh, InsTableThGroup, InsTableThead, InsTableTr, InsTabs, InsTabsDirective, InsTabsHorizontal, InsTabsStyles, InsTabsVertical, InsTabsWithMore, InsTextFieldController, InsTextFieldDataDirective, InsTextFieldSingleDataDirective, InsTextarea, InsTextareaCounterComponent, InsTextareaLimit, InsTextareaLimitComponent, InsTextfield, InsTextfieldComponent, InsTextfieldDirective, InsTextfieldDropdownDirective, InsTitle, InsTransitioned, InsTree, InsTreeChildren, InsTreeControllerDirective, InsTreeItem, InsTreeItemController, InsTreeService, InsValidationError, InsVehicle, InsWithAppearance, InsWithDropdownOpen, InsWithIcons, InsWithTextfieldDropdown, InsZoom, InsZoomService, LOCAL_STORAGE, MUTATION_OBSERVER_INIT, MutationObserver$1 as MutationObserver, MutationObserverService, NG_EVENT_PLUGINS, OptionsEventPlugin, POLYMORPHEUS_CONTEXT, PolymorpheusComponent, PolymorpheusContext, PolymorpheusOutlet, PolymorpheusTemplate, PreventEventPlugin, REDUCED_MOTION, RESIZE_OPTION_BOX, RESIZE_OPTION_BOX_DEFAULT, ResizeObserver$1 as ResizeObserver, ResizeObserverService, SafeObserver, SelfEventPlugin, SilentEventPlugin, StopEventPlugin, TextfieldOptionItem, WINDOW, commonIconsProvider, containsOrAfter, createToken, createTokenFromFactory, getActualTarget, getClosestFocusable, getDocumentOrShadowRoot, getNativeFocused, getViewportHeight, getViewportWidth, injectElement, insAlertOptionsProvider, insAppearanceOptionsProvider, insArrayRemove, insArrayToggle, insAsDataListAccessor, insAsDataListHost, insAsDriver, insAsPortal, insAsPositionAccessor, insAsRectAccessor, insAsVehicle, insAsViewport, insAssetsPathProvider, insAvatarOptionsProvider, insBlurNativeFocused, insButtonOptionsProvider, insCheckFixedPosition, insCheckboxOptionsProvider, insChipOptionsProvider, insClamp, insDropdownHoverOptionsProvider, insDropdownOptionsProvider, insExtractI18n, insFocusedIn, insFormOptionsProvider, insGetElementObscures, insGetSelectedText, insGetSemanticWordRange, insGetWordRange, insGroupOptionsProvider, insIconsProvider, insIfMap, insInjectIconResolver, insInjectId, insInputTagOptionsProvider, insIsElementEditable, insLabelOptionsProvider, insLinkOptionsProvider, insLoaderOptionsProvider, insMarkControlAsTouchedAndValidate, insMoveFocus, insNotificationOptionsProvider, insOverrideOptions, insProvide, insRadioOptionsProvider, insTableOptionsProvider, insTabsOptionsProvider, insTextareaOptionsProvider, insTextfieldOptionsProvider, insWithStyles, insZoneOptimized, insZonefree, insZonefreeScheduler, insZonefull, insZonefullScheduler, isEditingKey, isElement, isHTMLElement, isInput, isNativeFocused, isNativeFocusedIn, isNativeKeyboardFocusable, isNativeMouseFocusable, isPresent, isTextNode, isTextarea, isTextfield, provideMutationObserverInit, provideOptions, svgNodeFilter };
+export type { GetClosestFocusableOptions, InsAlertContext, InsAlertOptions, InsAppearanceOptions, InsAvatarOptions, InsBooleanHandler, InsBreakpointMediaKey, InsButtonOptions, InsCheckboxOptions, InsChipOptions, InsCommonIcons, InsContext, InsCountryIsoCode, InsDataListAccessor, InsDataListHost, InsDialogContext, InsDialogOptions, InsDropdownAlign, InsDropdownHoverOptions, InsDropdownOptions, InsDropdownWidth, InsFileLike, InsFileState, InsFormOptions, InsGroupOptions, InsHandler, InsHorizontalDirection, InsIdentityMatcher, InsInputTagOptions, InsInteractiveState, InsLabelOptions, InsLanguage, InsLanguageCore, InsLanguageKit, InsLanguageMeta, InsLanguageName, InsLinkOptions, InsLoaderOptions, InsMapper, InsMatcher, InsMedia, InsNotificationOptions, InsNumberHandler, InsPoint, InsPortalContext, InsPortalItem, InsPositionOptions, InsRadioOptions, InsSpinIcons, InsStringHandler, InsStringMatcher, InsSwipeDirection, InsSwipeEvent, InsSwipeOptions, InsTableOptions, InsTabsOptions, InsTextFieldAccessor, InsTextareaOptions, InsTextfieldOptions, InsTreeAccessor, InsTreeContext, InsTreeController, InsTreeItemContext, InsTreeLoader, InsVerticalDirection, InsZoomEvent, InsZoomOptions, PolymorpheusContent, PolymorpheusPrimitive, Storage };