@ngbase/adk 0.1.11 → 0.1.14

package/hover-card/index.d.ts

@@ -1,5 +1,21 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/hover-card" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { TemplateRef } from '@angular/core';
+import { PopoverOptions } from '@ngbase/adk/popover';
+
+declare class NgbHoverCard<T = any> {
+    private popoverPortal;
+    private el;
+    readonly ngbHoverCard: _angular_core.InputSignal<TemplateRef<T>>;
+    readonly options: _angular_core.InputSignal<PopoverOptions | undefined>;
+    readonly delay: _angular_core.InputSignalWithTransform<number, unknown>;
+    private close;
+    private inTimer;
+    private outTimer;
+    open(): void;
+    private resetOut;
+    closePopup(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbHoverCard<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbHoverCard<any>, "[ngbHoverCard]", ["ngbHoverCard"], { "ngbHoverCard": { "alias": "ngbHoverCard"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { NgbHoverCard };

package/icon/index.d.ts

@@ -1,5 +1,28 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/icon" />
-export * from './public-api';
+import * as _angular_platform_browser from '@angular/platform-browser';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+type IconLoaderFn = (name: string) => Promise<string>;
+declare const ICON_LOADER: InjectionToken<IconLoaderFn>;
+declare class IconService {
+    readonly loader: IconLoaderFn;
+    readonly icons: Map<string, string>;
+    private readonly pendingRequests;
+    getIcon(name: string): Promise<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IconService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IconService>;
+}
+
+declare class NgbIcon {
+    readonly service: IconService;
+    readonly sanitizer: DomSanitizer;
+    readonly name: i0.InputSignal<string>;
+    private readonly icon;
+    readonly svg: i0.Signal<_angular_platform_browser.SafeHtml>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbIcon, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbIcon, "[ngbIcon]", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { ICON_LOADER, NgbIcon };
+export type { IconLoaderFn };

package/index.d.ts

@@ -1,5 +1,2 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk" />
-export * from './public-api';
+
+export { };

package/inline-edit/index.d.ts

@@ -1,5 +1,53 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/inline-edit" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i1 from '@ngbase/adk/form-field';
+import { InputBase } from '@ngbase/adk/form-field';
+
+declare class NgbInlineInput {
+    readonly ie: NgbInlineEdit;
+    readonly inputBase: InputBase<any>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInlineInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInlineInput, "[ngbInlineInput]", never, {}, {}, never, never, true, [{ directive: typeof i1.InputBase; inputs: {}; outputs: {}; }]>;
+}
+declare class NgbInlineValue {
+    readonly ie: NgbInlineEdit;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInlineValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInlineValue, "[ngbInlineValue]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbInlineEdit implements ControlValueAccessor {
+    private readonly el;
+    private readonly disposals;
+    readonly inputElement: _angular_core.Signal<ElementRef<any> | undefined>;
+    readonly value: _angular_core.InputSignal<string>;
+    readonly editOn: _angular_core.InputSignal<"click" | "dblclick">;
+    readonly valueChange: _angular_core.OutputEmitterRef<string>;
+    readonly afterEdit: _angular_core.OutputEmitterRef<string>;
+    readonly localValue: _angular_core.WritableSignal<string>;
+    readonly isEditing: _angular_core.WritableSignal<boolean>;
+    readonly inputWidth: _angular_core.WritableSignal<number>;
+    onChange?: (value: string) => void;
+    onTouched?: () => void;
+    onClick(): void;
+    onDoubleClick(): void;
+    startEditing(): void;
+    onBlur(): void;
+    onEnter(ev: Event): void;
+    updateValue(newValue: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    writeValue(value: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInlineEdit, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInlineEdit, "[ngbInlineEdit]", never, { "value": { "alias": "value"; "required": false; "isSignal": true; }; "editOn": { "alias": "editOn"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; "afterEdit": "afterEdit"; }, never, never, true, never>;
+}
+declare function aliasInlineEdit(inlineEdit: typeof NgbInlineEdit): ({
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+} | {
+    provide: typeof NgbInlineEdit;
+    useExisting: typeof NgbInlineEdit;
+})[];
+
+export { NgbInlineEdit, NgbInlineInput, NgbInlineValue, aliasInlineEdit };

package/jwt/index.d.ts

@@ -1,5 +1,20 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/jwt" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+
+interface JwtOptions {
+    tokenGetter: () => string | null | undefined;
+}
+declare function provideJwt(options: () => JwtOptions): i0.EnvironmentProviders;
+declare class JwtService<T> {
+    private tokenKey;
+    private options;
+    getToken(): string | null;
+    isTokenExpired(token?: string): boolean;
+    decodeToken(token?: string): T | null;
+    getTokenExpirationDate(token?: string): Date | null;
+    private base64UrlDecode;
+    static ɵfac: i0.ɵɵFactoryDeclaration<JwtService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<JwtService<any>>;
+}
+declare const injectJwt: () => JwtService<any>;
+
+export { JwtService, injectJwt, provideJwt };

package/keys/index.d.ts

@@ -1,5 +1,54 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/keys" />
-export * from './public-api';
+import * as rxjs from 'rxjs';
+import * as i0 from '@angular/core';
+import { Injector } from '@angular/core';
+
+declare class Keys {
+    private document;
+    private keyup$;
+    private keydown$;
+    private keypress$;
+    lastEvent?: KeyboardEvent;
+    private keys;
+    event(keyCombination: string): rxjs.Observable<[boolean, KeyboardEvent]>;
+    isKey(key: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Keys, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Keys>;
+}
+
+interface Shortcut {
+    callback: (ev: KeyboardEvent) => void;
+    prevent: boolean;
+    stop: boolean;
+    global: boolean;
+    id: string;
+}
+declare class Shortcuts {
+    private readonly shortcuts;
+    private isActive;
+    private isClient;
+    on(keyCombination: string, data: Shortcut): void;
+    off(keyCombination: string, id: string): void;
+    /**
+     * We need to parse the key combination
+     * e.g. ⇧⌘P -> shift+meta+p, ⌥⌘P -> meta+alt+p, ctrl+p -> ctrl+p
+     * e.g. esc|prevent|stop|global -> escape
+     */
+    private getParsedKey;
+    private handleKeyEvent;
+    private keydown;
+    private shouldIgnoreEvent;
+    private getKeyCombo;
+    private turnOff;
+    private turnOn;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Shortcuts, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Shortcuts>;
+}
+declare function keyMap(key: string, callback: (ev: KeyboardEvent) => void, data?: {
+    injector?: Injector;
+    cleanup?: (off: () => void) => void;
+    stop?: boolean;
+    global?: boolean;
+    prevent?: boolean;
+}): () => void;
+
+export { Keys, Shortcuts, keyMap };

package/layout/index.d.ts

@@ -1,5 +1,20 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/layout" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+
+declare function breakpointObserver(): {
+    observe: <T extends string>(queries: Record<T, string>) => {
+        state: _angular_core.Signal<Record<T, boolean>>;
+        unobserve: () => void;
+    };
+    matches: (queryName: string) => boolean;
+};
+declare function setupTestBreakpoint(fn: Function): {
+    reset: () => void;
+    readonly mediaQueryList: {
+        matches: boolean;
+        addEventListener: any;
+        removeEventListener: any;
+    };
+    readonly matchMedia: any;
+};
+
+export { breakpointObserver, setupTestBreakpoint };

package/list/index.d.ts

@@ -1,5 +1,34 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/list" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import * as i1 from '@ngbase/adk/a11y';
+
+declare class NgbList {
+    private readonly allyItem;
+    readonly el: ElementRef<HTMLElement>;
+    readonly ayId: i0.InputSignal<string | undefined>;
+    readonly disabled: i0.InputSignalWithTransform<boolean, unknown>;
+    constructor();
+    setAyId(id: string): void;
+    select(): void;
+    focus(): void;
+    unselect(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbList, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbList, "[ngbList]", never, { "ayId": { "alias": "ayId"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: { "role": "role"; "disabled": "disabled"; }; outputs: {}; }]>;
+}
+declare function provideList(list: typeof NgbList): {
+    provide: typeof NgbList;
+    useExisting: typeof NgbList;
+};
+
+declare class NgbListActionGroup {
+    readonly options: i0.Signal<readonly NgbList[]>;
+    private readonly activeIndex;
+    private readonly optionsMap;
+    constructor();
+    private handleKeyDown;
+    private afterAction;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbListActionGroup, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbListActionGroup, "[ngbActionGroup]", never, {}, {}, ["options"], never, true, never>;
+}
+
+export { NgbList, NgbListActionGroup, provideList };

package/mask/index.d.ts

@@ -1,5 +1,33 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/mask" />
-export * from './public-api';
+import * as i0 from '@angular/core';
+import { PipeTransform } from '@angular/core';
+import { NgControl } from '@angular/forms';
+
+declare class Mask {
+    private readonly el;
+    readonly control: NgControl | null;
+    private readonly inputC;
+    readonly ngbMask: i0.InputSignal<string>;
+    readonly showMaskType: i0.InputSignal<boolean>;
+    readonly localValue: i0.WritableSignal<string>;
+    constructor();
+    onKeyDown(event: KeyboardEvent): void;
+    getCurrentMaskChar(mask: string, cursorPos: number): string;
+    onPaste(event: ClipboardEvent): void;
+    private isValidChar;
+    handleValue(value: string, cursorPos?: number): void;
+    private calculateCursorPosition;
+    private updateLocalValue;
+    writeValue(value: string): void;
+    private updateView;
+    private unmask;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Mask, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<Mask, "[ngbMask]", never, { "ngbMask": { "alias": "ngbMask"; "required": false; "isSignal": true; }; "showMaskType": { "alias": "showMaskType"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class MaskPipe implements PipeTransform {
+    transform(value: string, mask: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MaskPipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<MaskPipe, "mask", true>;
+}
+
+export { Mask, MaskPipe };

package/menu/index.d.ts

@@ -1,5 +1,145 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/menu" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ElementRef, OnDestroy, TemplateRef } from '@angular/core';
+import * as _ngbase_adk_portal from '@ngbase/adk/portal';
+import { DialogRef } from '@ngbase/adk/portal';
+import * as _ngbase_adk_popover from '@ngbase/adk/popover';
+import { PopoverOptions } from '@ngbase/adk/popover';
+import * as _ngbase_adk_bidi from '@ngbase/adk/bidi';
+import * as i1 from '@ngbase/adk/a11y';
+import { AccessibleItem, AccessibleGroup } from '@ngbase/adk/a11y';
+import { Keys } from '@ngbase/adk/keys';
+import { NgbList } from '@ngbase/adk/list';
+import { NgbOption } from '@ngbase/adk/select';
+import { Subject, BehaviorSubject } from 'rxjs';
+
+declare class NgbMenuTrigger {
+    private readonly nav;
+    private readonly parent;
+    readonly el: ElementRef<HTMLElement>;
+    readonly a11y: AccessibleItem<any> | null;
+    readonly ngbMenuTrigger: _angular_core.InputSignal<NgbMenu>;
+    readonly ngbMenuTriggerData: _angular_core.InputSignal<unknown>;
+    readonly options: _angular_core.InputSignal<Partial<PopoverOptions>>;
+    private readonly _menuOpen;
+    readonly menuOpen: _angular_core.Signal<boolean>;
+    readonly events: Subject<{
+        event: MouseEvent;
+        type: "enter" | "leave" | "click";
+        menu: NgbMenuTrigger;
+    }>;
+    private closeParent;
+    private delayTimer;
+    private isMouseOverTrigger;
+    constructor();
+    private get menu();
+    get rootParent(): NgbMenu | null;
+    clickOpen(ev: MouseEvent): void;
+    private open;
+    closeMenu(): void;
+    openMenu(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbMenuTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbMenuTrigger, "[ngbMenuTrigger]", ["ngbMenuTrigger"], { "ngbMenuTrigger": { "alias": "ngbMenuTrigger"; "required": true; "isSignal": true; }; "ngbMenuTriggerData": { "alias": "ngbMenuTriggerData"; "required": false; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+declare class NgpMenuGroup {
+    readonly menu: NgbMenu;
+    readonly allyGroup: AccessibleGroup;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenuGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenuGroup, "[ngbMenuGroup]", never, {}, {}, never, never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+declare class NgpMenuContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgpMenuContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgpMenuContent, "ng-template[ngbMenuContent]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbMenu implements OnDestroy {
+    readonly dir: _ngbase_adk_bidi.Directionality;
+    readonly popover: {
+        open: <T>(component: _ngbase_adk_portal.DialogInput<T>, options: PopoverOptions) => _ngbase_adk_popover.PopoverOpen<T>;
+        closeAll: () => void;
+    };
+    private readonly menuEl;
+    readonly container: _angular_core.Signal<TemplateRef<any>>;
+    readonly content: _angular_core.Signal<readonly TemplateRef<any>[]>;
+    readonly options: _angular_core.Signal<readonly NgbOption<any>[]>;
+    readonly lists: _angular_core.Signal<readonly NgbList[]>;
+    readonly manager: Keys;
+    readonly selected: _angular_core.OutputEmitterRef<string>;
+    readonly ayId: string;
+    readonly noAutoClose: _angular_core.InputSignal<boolean>;
+    parentMenuTrigger?: NgbMenuTrigger;
+    diaRef: DialogRef;
+    readonly events: Subject<{
+        event: MouseEvent;
+        type: "enter" | "leave";
+    }>;
+    readonly activeOption: BehaviorSubject<NgbOption<any> | NgbList | null>;
+    isOpen: boolean;
+    constructor();
+    open(options: PopoverOptions, subMenu?: boolean): void;
+    opened(): void;
+    get rootParent(): NgbMenu | undefined;
+    close: (data?: any) => void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbMenu, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbMenu, "[ngbMenu]", ["ngbMenu"], { "noAutoClose": { "alias": "noAutoClose"; "required": false; "isSignal": true; }; }, { "selected": "selected"; }, ["content", "options", "lists"], never, true, never>;
+}
+declare const aliasMenu: (menu: typeof NgbMenu) => {
+    provide: typeof NgbMenu;
+    useExisting: typeof NgbMenu;
+};
+
+declare class MenuService {
+    private currentRef;
+    close(): void;
+    setCurrentRef(ref: DialogRef<any>): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MenuService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MenuService>;
+}
+declare class NgbContextMenu {
+    readonly ngbContextMenu: _angular_core.InputSignal<NgbMenu>;
+    readonly menuService: MenuService;
+    readonly ctxOpen: _angular_core.OutputEmitterRef<boolean>;
+    readonly ctxClose: _angular_core.OutputEmitterRef<boolean>;
+    private listeners;
+    open(ev: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbContextMenu, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbContextMenu, "[ngbContextMenu]", never, { "ngbContextMenu": { "alias": "ngbContextMenu"; "required": true; "isSignal": true; }; }, { "ctxOpen": "ctxOpen"; "ctxClose": "ctxClose"; }, never, never, true, never>;
+}
+
+declare class NgbMentionTrigger {
+    private readonly el;
+    readonly ngbMentionTrigger: _angular_core.InputSignal<NgbMenu>;
+    readonly options: _angular_core.InputSignal<{
+        focus?: "el";
+        width?: "full";
+    } | undefined>;
+    readonly key: _angular_core.InputSignal<string>;
+    readonly search: _angular_core.OutputEmitterRef<string>;
+    private close?;
+    open(): void;
+    private getCurrentWord;
+    private getPositionAt;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbMentionTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbMentionTrigger, "[ngbMentionTrigger]", never, { "ngbMentionTrigger": { "alias": "ngbMentionTrigger"; "required": true; "isSignal": true; }; "options": { "alias": "options"; "required": false; "isSignal": true; }; "key": { "alias": "key"; "required": true; "isSignal": true; }; }, { "search": "search"; }, never, never, true, never>;
+}
+
+declare class NgbNavigationMenu {
+    private popover;
+    private readonly dir;
+    private readonly menus;
+    readonly hover: _angular_core.InputSignal<boolean>;
+    private ayId;
+    close?: VoidFunction;
+    private timerId;
+    private popoverOpen?;
+    private clicked;
+    private currentEl?;
+    constructor();
+    open(menuTrigger: NgbMenuTrigger): void;
+    private scheduleClose;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbNavigationMenu, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbNavigationMenu, "[ngbNavigationMenu]", never, { "hover": { "alias": "hover"; "required": false; "isSignal": true; }; }, {}, ["menus"], never, true, never>;
+}
+
+export { NgbContextMenu, NgbMentionTrigger, NgbMenu, NgbMenuTrigger, NgbNavigationMenu, NgpMenuContent, NgpMenuGroup, aliasMenu };

package/network/index.d.ts

@@ -1,5 +1,29 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/network" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import * as _angular_common_http from '@angular/common/http';
+import { HttpInterceptorFn } from '@angular/common/http';
+
+declare const provideNetworkInterceptor: () => {
+    provide: _angular_core.InjectionToken<readonly _angular_common_http.HttpInterceptor[]>;
+    useFactory: HttpInterceptorFn;
+    multi: boolean;
+};
+
+declare class Network {
+    private status;
+    readonly isOnline: _angular_core.Signal<boolean>;
+    private listeners;
+    private initialized;
+    private onlineListener;
+    private offlineListener;
+    constructor();
+    private on;
+    private off;
+    private updateOnlineStatus;
+    addListener(listener: (status: boolean) => void): void;
+    removeListener(listener: (status: boolean) => void): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<Network, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<Network>;
+}
+declare const injectNetwork: () => Network;
+
+export { Network, injectNetwork, provideNetworkInterceptor };

package/otp/index.d.ts

@@ -1,5 +1,51 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@ngbase/adk/otp" />
-export * from './public-api';
+import * as _angular_core from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+
+declare class NgbOtpInput {
+    readonly otp: NgbInputOtp;
+    readonly el: ElementRef<HTMLInputElement>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbOtpInput, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbOtpInput, "input[ngbOtpInput]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbOtpValue {
+    readonly otp: NgbInputOtp;
+    readonly el: ElementRef<HTMLElement>;
+    readonly index: _angular_core.Signal<number>;
+    readonly value: _angular_core.Signal<string>;
+    readonly focused: _angular_core.Signal<boolean>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbOtpValue, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbOtpValue, "[ngbOtpValue]", never, {}, {}, never, never, true, never>;
+}
+declare class NgbInputOtp implements ControlValueAccessor {
+    private readonly inputs;
+    readonly _otpValues: _angular_core.Signal<readonly NgbOtpValue[]>;
+    readonly size: _angular_core.InputSignal<number[]>;
+    readonly masked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignal<boolean>;
+    readonly no: _angular_core.Signal<number>;
+    private onChange?;
+    private onTouched?;
+    private lastValue;
+    readonly values: _angular_core.WritableSignal<string>;
+    readonly focused: _angular_core.WritableSignal<boolean>;
+    constructor();
+    private updateNewValue;
+    writeValue(value: string): void;
+    updateValue(values: string): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<NgbInputOtp, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<NgbInputOtp, "[ngbInputOtp]", never, { "size": { "alias": "size"; "required": false; "isSignal": true; }; "masked": { "alias": "masked"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+declare function aliasInputOtp(otp: typeof NgbInputOtp): ({
+    provide: _angular_core.InjectionToken<readonly ControlValueAccessor[]>;
+    useExisting: _angular_core.Type<any>;
+    multi: boolean;
+}[] | {
+    provide: typeof NgbInputOtp;
+    useExisting: typeof NgbInputOtp;
+})[];
+
+export { NgbInputOtp, NgbOtpInput, NgbOtpValue, aliasInputOtp };