@ngbase/adk 0.1.0

package/toggle-group/toggle-item.d.ts

@@ -0,0 +1,14 @@
+import { NgbToggleGroup } from './toggle-group';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export declare class NgbToggleItem<T> {
+    private accessibleItem;
+    readonly toggleGroup: NgbToggleGroup<T>;
+    readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+    readonly value: import("@angular/core").InputSignal<any>;
+    readonly active: import("@angular/core").Signal<boolean>;
+    constructor();
+    updateValue(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbToggleItem<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbToggleItem<any>, "button[ngbToggleItem]", never, { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": true; "isSignal": true; }; }, {}, never, never, true, [{ directive: typeof i1.AccessibleItem; inputs: { "disabled": "disabled"; }; outputs: {}; }]>;
+}

package/tooltip/index.d.ts

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

package/tooltip/public-api.d.ts

@@ -0,0 +1,2 @@
+export { NgbTooltipTemplate } from './tooltip';
+export { NgbTooltip, provideNgbTooltipOptions, type TooltipOptions } from './tooltip.directive';

package/tooltip/tooltip.d.ts

@@ -0,0 +1,20 @@
+import { ElementRef, OnDestroy } from '@angular/core';
+import { PopoverPosition } from '@ngbase/adk/popover';
+import * as i0 from "@angular/core";
+export declare class NgbTooltipTemplate implements OnDestroy {
+    readonly el: ElementRef<HTMLElement>;
+    readonly content: import("@angular/core").WritableSignal<string>;
+    private target;
+    private position;
+    private hide;
+    private observer?;
+    constructor();
+    update(content: string, target: HTMLElement, position: PopoverPosition, hide: VoidFunction): void;
+    private setTarget;
+    private listenTarget;
+    private onRemoved;
+    setPosition(target: HTMLElement): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTooltipTemplate, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTooltipTemplate, "[ngbTooltip]", never, {}, {}, never, never, true, never>;
+}

package/tooltip/tooltip.directive.d.ts

@@ -0,0 +1,34 @@
+import { InjectionToken, OnDestroy, Type } from '@angular/core';
+import { PopoverPosition } from '@ngbase/adk/popover';
+import { NgbTooltipTemplate } from './tooltip';
+import * as i0 from "@angular/core";
+export declare function provideNgbTooltipOptions(options: TooltipOptions): {
+    provide: InjectionToken<TooltipOptions>;
+    useValue: TooltipOptions;
+};
+export declare const TOOLTIP_OPTIONS: InjectionToken<TooltipOptions>;
+export interface TooltipOptions {
+    showDelay?: number;
+    hideDelay?: number;
+    position?: PopoverPosition;
+    component?: Type<NgbTooltipTemplate>;
+}
+export declare class NgbTooltip implements OnDestroy {
+    private defaultOptions;
+    private el;
+    private tooltipService;
+    readonly ngbTooltip: import("@angular/core").InputSignal<string | undefined>;
+    readonly ngbTooltipPosition: import("@angular/core").InputSignal<PopoverPosition | undefined>;
+    readonly delay: import("@angular/core").InputSignal<number>;
+    readonly options: import("@angular/core").Signal<TooltipOptions>;
+    timer: any;
+    constructor();
+    show: () => void;
+    removed: () => void;
+    hide: () => void;
+    quickHide: () => void;
+    private remove;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTooltip, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTooltip, "[ngbTooltip]", never, { "ngbTooltip": { "alias": "ngbTooltip"; "required": false; "isSignal": true; }; "ngbTooltipPosition": { "alias": "ngbTooltipPosition"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/tooltip/tooltip.service.d.ts

@@ -0,0 +1,26 @@
+import { ComponentRef, Type } from '@angular/core';
+import { DialogInput } from '@ngbase/adk/portal';
+import { PopoverPosition } from '@ngbase/adk/popover';
+import { NgbTooltipTemplate } from './tooltip';
+import * as i0 from "@angular/core";
+export declare class TooltipService {
+    tooltip: {
+        open: (content: string, target: HTMLElement, position: PopoverPosition, hide: VoidFunction, parentComponent?: Type<NgbTooltipTemplate>) => TooltipOpen;
+    };
+    tooltipOpen: TooltipOpen | undefined;
+    timeoutId: any;
+    delay: number;
+    insert(el: HTMLElement, content: string, position: PopoverPosition, hide: VoidFunction, component?: Type<NgbTooltipTemplate>): void;
+    destroy: () => void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TooltipService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TooltipService>;
+}
+interface TooltipOpen {
+    destroy: VoidFunction;
+    parent: ComponentRef<NgbTooltipTemplate>;
+    replace: ((component: DialogInput<NgbTooltipTemplate>) => void) | undefined;
+}
+export declare function tooltipPortal(): {
+    open: (content: string, target: HTMLElement, position: PopoverPosition, hide: VoidFunction, parentComponent?: Type<NgbTooltipTemplate>) => TooltipOpen;
+};
+export {};

package/tour/animation.d.ts

@@ -0,0 +1,2 @@
+export declare const slideInOutAnimation: import("@angular/animations").AnimationTriggerMetadata;
+export declare const tourAnimation: import("@angular/animations").AnimationTriggerMetadata[];

package/tour/index.d.ts

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

package/tour/public-api.d.ts

@@ -0,0 +1,5 @@
+export * from './tour-step';
+export * from './tour';
+export * from './tour.service';
+export * from './tour-base';
+export * from './animation';

package/tour/tour-base.d.ts

@@ -0,0 +1,21 @@
+import { ElementRef, OnDestroy, ViewContainerRef } from '@angular/core';
+import { PopoverOptions } from '@ngbase/adk/popover';
+import { BaseDialog, DialogOptions } from '@ngbase/adk/portal';
+import { NgbTourService } from './tour.service';
+import * as i0 from "@angular/core";
+export declare class NgbBaseTour extends BaseDialog implements OnDestroy {
+    readonly tourService: NgbTourService;
+    readonly myDialog: import("@angular/core").Signal<ViewContainerRef | undefined>;
+    readonly container: import("@angular/core").Signal<ElementRef<HTMLElement> | undefined>;
+    options: DialogOptions;
+    tooltipOptions: PopoverOptions;
+    private lastPosition;
+    readonly scrolled: import("@angular/core").WritableSignal<number>;
+    readonly clipPath: import("@angular/core").Signal<string>;
+    constructor();
+    private updateDimension;
+    setOptions(options: DialogOptions): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbBaseTour, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbBaseTour, "[ngbTour]", never, {}, {}, never, never, true, never>;
+}

package/tour/tour-step.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef } from '@angular/core';
+import { NgbTourService } from './tour.service';
+import * as i0 from "@angular/core";
+export declare class NgbTourStep {
+    readonly el: ElementRef<any>;
+    readonly tourService: NgbTourService;
+    readonly ngbTourStep: import("@angular/core").InputSignal<string>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTourStep, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTourStep, "[ngbTourStep]", never, { "ngbTourStep": { "alias": "ngbTourStep"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}

package/tour/tour.d.ts

@@ -0,0 +1,9 @@
+import { NgbTourService } from './tour.service';
+import { NgbTourStep } from './tour-step';
+import * as i0 from "@angular/core";
+export declare class NgbTour {
+    readonly tourService: NgbTourService;
+    readonly steps: import("@angular/core").Signal<readonly NgbTourStep[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTour, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTour, "[ngbTour]", never, {}, {}, ["steps"], never, true, never>;
+}

package/tour/tour.service.d.ts

@@ -0,0 +1,30 @@
+import { DialogInput } from '@ngbase/adk/portal';
+import { NgbTourStep } from './tour-step';
+import * as i0 from "@angular/core";
+export declare class NgbTourService {
+    private popover;
+    readonly steps: import("@angular/core").WritableSignal<NgbTourStep[]>;
+    readonly step: import("@angular/core").WritableSignal<number>;
+    private readonly ids;
+    currentStep: import("@angular/core").Signal<NgbTourStep | undefined>;
+    private diaRef?;
+    private id;
+    private template;
+    readonly showPrev: import("@angular/core").Signal<boolean>;
+    readonly showNext: import("@angular/core").Signal<boolean>;
+    readonly isLast: import("@angular/core").Signal<boolean>;
+    readonly totalSteps: import("@angular/core").Signal<number>;
+    scrolled: import("@angular/core").WritableSignal<number>;
+    private clipPath;
+    constructor();
+    addStep(step: NgbTourStep): void;
+    start<T>(comp: DialogInput<T>, ids: string[]): void;
+    prev(): void;
+    next(): void;
+    go(id: number): void;
+    stop(): void;
+    private showOverlay;
+    private hideOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTourService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NgbTourService>;
+}

package/translate/config.d.ts

@@ -0,0 +1,16 @@
+import { InjectionToken } from '@angular/core';
+import { Observable } from 'rxjs';
+import { TranslateService } from './translate.service';
+export type Translation<T = any> = Record<string, T>;
+export interface TranslateConfig {
+    defaultLang: string;
+    preloadedLanguages?: Record<string, Translation>;
+    path?: string;
+    loader?: (lang: string, fallbackLang: string, config: TranslateConfig) => Observable<Translation>;
+}
+export declare const TRANSLATE_CONFIG: InjectionToken<TranslateConfig>;
+export declare function provideTranslate(config: TranslateConfig): (typeof TranslateService | import("@angular/core").EnvironmentProviders | {
+    provide: InjectionToken<TranslateConfig>;
+    useValue: TranslateConfig;
+})[];
+export declare function interpolate(translation: string, params: Record<string, any>): string;

package/translate/index.d.ts

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

package/translate/public-api.d.ts

@@ -0,0 +1,3 @@
+export { Translate, translate } from './translate';
+export { type TranslateConfig, provideTranslate } from './config';
+export { injectTranslate } from './translate.service';

package/translate/translate.d.ts

@@ -0,0 +1,11 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class Translate implements PipeTransform {
+    private translate;
+    private value;
+    private linkedValue;
+    transform(value: string, ...args: any[]): import("@angular/core").WritableSignal<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Translate, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<Translate, "t", true>;
+}
+export declare function translate(): (value: string, ...args: any[]) => string;

package/translate/translate.service.d.ts

@@ -0,0 +1,31 @@
+import { EnvironmentInjector } from '@angular/core';
+import { Translation } from './config';
+import * as i0 from "@angular/core";
+export declare class TranslateService {
+    private config;
+    private readonly _defaultLang;
+    private readonly _currentLang;
+    readonly defaultLang: import("@angular/core").Signal<string>;
+    readonly currentLang: import("@angular/core").Signal<string>;
+    private lastLang;
+    private readonly cachedTranslations;
+    private readonly _translationData;
+    readonly translations: import("@angular/core").Signal<Translation>;
+    readonly envInjector: EnvironmentInjector;
+    readonly status: import("@angular/core").WritableSignal<"error" | "loading" | "done">;
+    init(): import("rxjs").Observable<Translation<any>>;
+    setDefaultLang(lang: string): void;
+    use(lang: string): void;
+    private loadTranslations;
+    /**
+     * @key - The key to translate.
+     * @data - The data to pass to the translation.
+     * @returns The translated value.
+     * The key can be a string or a nested key.
+     * The data is used to interpolate the translation.
+     */
+    translate: (key: string, params?: Record<string, any>, translationData?: Translation) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslateService>;
+}
+export declare const injectTranslate: () => TranslateService;

package/tree/index.d.ts

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

package/tree/public-api.d.ts

@@ -0,0 +1,3 @@
+export { NgbTree, provideTree } from './tree';
+export { NgbTreeNode, provideTreeNode } from './tree-node';
+export { NgbTreeNodeToggle, NgbTreeNodeDef, NgbTreeNodeContent } from './tree-toggle';

package/tree/tree-node.d.ts

@@ -0,0 +1,28 @@
+import { Type, ViewContainerRef } from '@angular/core';
+import { NgbTree, TreeNodeData } from './tree';
+import { NgbTreeNodeDef } from './tree-toggle';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export declare class NgbTreeNode<T> {
+    readonly treeNodeDef: NgbTreeNodeDef<any>;
+    readonly tree: NgbTree<T>;
+    readonly data: TreeNodeData<T>;
+    readonly container: import("@angular/core").Signal<ViewContainerRef | undefined>;
+    readonly isOpen: import("@angular/core").Signal<boolean>;
+    readonly parent: import("@angular/core").Signal<T | undefined>;
+    private readonly children;
+    readonly hasChildren: import("@angular/core").Signal<boolean>;
+    readonly dir: import("@ngbase/adk/bidi").Directionality;
+    readonly size: import("@angular/core").WritableSignal<number>;
+    readonly padding: import("@angular/core").Signal<{
+        [x: string]: string;
+    }>;
+    constructor();
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTreeNode<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTreeNode<any>, "[ngbTreeNode]", ["ngbTreeNode"], {}, {}, never, ["*", "[ngbTreeNodeContent]"], true, [{ directive: typeof i1.AccessibleItem; inputs: {}; outputs: {}; }]>;
+}
+export declare function provideTreeNode<T>(treeNode: Type<NgbTreeNode<T>>): {
+    provide: typeof NgbTreeNode;
+    useExisting: Type<NgbTreeNode<T>>;
+};

package/tree/tree-toggle.d.ts

@@ -0,0 +1,16 @@
+import { NgbTreeNode } from './tree-node';
+import * as i0 from "@angular/core";
+export declare class NgbTreeNodeToggle {
+    treeNode: NgbTreeNode<any>;
+    toggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTreeNodeToggle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTreeNodeToggle, "[ngbTreeNodeToggle]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbTreeNodeDef<T> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTreeNodeDef<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTreeNodeDef<any>, "[ngbTreeNodeDef]", never, {}, {}, never, never, true, never>;
+}
+export declare class NgbTreeNodeContent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTreeNodeContent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbTreeNodeContent, "[ngbTreeNodeContent]", never, {}, {}, never, never, true, never>;
+}

package/tree/tree.d.ts

@@ -0,0 +1,55 @@
+import { EmbeddedViewRef, InjectionToken, TemplateRef, Type, ViewContainerRef } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@ngbase/adk/a11y";
+export declare const TREE_NODE_DATA: InjectionToken<TreeNodeData<any>>;
+export type TreeAction = 'add' | 'addAll' | 'delete' | 'deleteAll';
+interface FlatNode {
+    expandable: boolean;
+    id: string;
+    level: number;
+    isExpanded?: boolean;
+    parentId?: string;
+    index: number;
+    childrenCount: number;
+}
+export interface TreeNodeData<T> {
+    level: number;
+    details: FlatNode;
+    data: T;
+}
+export interface TreeNodeImplicit<T> {
+    $implicit: T;
+    level: number;
+}
+export declare class NgbTree<T> {
+    private readonly injector;
+    private readonly differs;
+    readonly ayId: string;
+    readonly treeNodeDef: import("@angular/core").Signal<TemplateRef<any>>;
+    readonly container: import("@angular/core").Signal<ViewContainerRef>;
+    readonly dataSource: import("@angular/core").InputSignal<T[]>;
+    readonly trackBy: import("@angular/core").InputSignal<(index: number, item: T) => any>;
+    readonly children: import("@angular/core").InputSignal<(node: T) => T[]>;
+    readonly opened: import("@angular/core").WritableSignal<Set<string>>;
+    readonly trace: Map<string, {
+        ref: EmbeddedViewRef<TreeNodeImplicit<T>>;
+        parent: FlatNode;
+    }>;
+    private readonly _dataDiffers;
+    private readonly flattener;
+    private expanded;
+    constructor();
+    private removeNode;
+    getNode(id: string): T | undefined;
+    private renderNode;
+    toggle(data: FlatNode): void;
+    foldAll(): void;
+    expandAll(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTree<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTree<any>, "[ngbTree]", ["ngbTree"], { "dataSource": { "alias": "dataSource"; "required": true; "isSignal": true; }; "trackBy": { "alias": "trackBy"; "required": true; "isSignal": true; }; "children": { "alias": "children"; "required": true; "isSignal": true; }; }, {}, ["treeNodeDef"], never, true, [{ directive: typeof i1.AccessibleGroup; inputs: {}; outputs: {}; }]>;
+}
+export declare function provideTree<T>(tree: Type<NgbTree<T>>): {
+    provide: typeof NgbTree;
+    useExisting: Type<NgbTree<T>>;
+};
+export {};

package/utils/animation.d.ts

@@ -0,0 +1,3 @@
+import { AnimationTriggerMetadata } from '@angular/animations';
+export declare const createHostAnimation: (animationNames: string[]) => AnimationTriggerMetadata;
+export declare function fadeAnimation(time: string): AnimationTriggerMetadata;

package/utils/disposals.d.ts

@@ -0,0 +1,7 @@
+type Cleanup = () => void;
+type CleanupRegisterFn = (fn: Cleanup) => void;
+export declare function disposals(): {
+    afterNextRender: (fn: (cleanup: CleanupRegisterFn) => void) => () => void;
+};
+export declare function cleanup(fn: () => void): void;
+export {};

package/utils/index.d.ts

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

package/utils/number-only.d.ts

@@ -0,0 +1,22 @@
+import { ElementRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NumberOnly {
+    readonly el: ElementRef<HTMLInputElement>;
+    readonly min: import("@angular/core").InputSignal<number | undefined>;
+    readonly max: import("@angular/core").InputSignal<number | undefined>;
+    readonly len: import("@angular/core").InputSignal<number | undefined>;
+    readonly value: import("@angular/core").ModelSignal<string>;
+    readonly _min: import("@angular/core").WritableSignal<number | undefined>;
+    readonly _max: import("@angular/core").WritableSignal<number | undefined>;
+    readonly _len: import("@angular/core").WritableSignal<number | undefined>;
+    constructor();
+    private readonly allowedKeys;
+    onKeyDown: (e: KeyboardEvent) => void;
+    private isCtrlKey;
+    private handleArrowUpDown;
+    private getNewValue;
+    private validateValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberOnly, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NumberOnly, "[ngbNumberOnly]", never, { "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "len": { "alias": "len"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; }, { "value": "valueChange"; }, never, never, true, never>;
+}
+export declare function padString(num: number | string): string;

package/utils/public-api.d.ts

@@ -0,0 +1,6 @@
+export * from './range.pipe';
+export * from './utils';
+export * from './disposals';
+export * from './ssr';
+export * from './animation';
+export * from './number-only';

package/utils/range.pipe.d.ts

@@ -0,0 +1,7 @@
+import { PipeTransform } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class RangePipe implements PipeTransform {
+    transform(value: number): number[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<RangePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<RangePipe, "range", true>;
+}

package/utils/ssr.d.ts

@@ -0,0 +1,2 @@
+export declare function isServer(): boolean;
+export declare function isClient(): boolean;

package/utils/utils.d.ts

@@ -0,0 +1,27 @@
+import { Injector, Signal, Type } from '@angular/core';
+export declare function uniqueId(length?: number): string;
+export declare function provideValueAccessor<T>(valueAccessor: Type<T>): {
+    provide: import("@angular/core").InjectionToken<readonly import("@angular/forms").ControlValueAccessor[]>;
+    useExisting: Type<any>;
+    multi: boolean;
+};
+export interface ListenerOut {
+    on: () => void;
+    off: () => void;
+}
+export declare function documentListener<T extends Event>(ev: string, fn: (e: T) => void, data?: Partial<AddEventListenerOptions & {
+    injector?: Injector;
+    lazy?: boolean;
+    skip?: number;
+    element?: HTMLElement | Document | Window;
+}>): ListenerOut;
+export declare function filterFunction<T, V = T>(data: Signal<T[]> | T[], options: {
+    filter?: (v: V) => string;
+    key?: keyof T;
+    childrenFilter?: (v: T) => V[];
+    query?: (v: V, search: string) => boolean;
+}): {
+    search: import("@angular/core").WritableSignal<string>;
+    list: import("@angular/core").WritableSignal<T[]>;
+    filteredList: Signal<T[]>;
+};

package/virtualizer/index.d.ts

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

package/virtualizer/public-api.d.ts

@@ -0,0 +1 @@
+export * from './virtualizer';

package/virtualizer/virtualizer.d.ts

@@ -0,0 +1,42 @@
+import { TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export type Orientation = 'vertical' | 'horizontal';
+export interface VirtualForContext<T> {
+    $implicit: T;
+    index: number;
+}
+export declare class VirtualFor<T> {
+    template: TemplateRef<VirtualForContext<T>>;
+    readonly virtualForOf: import("@angular/core").InputSignal<T[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<VirtualFor<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<VirtualFor<any>, "[virtualFor][virtualForOf]", never, { "virtualForOf": { "alias": "virtualForOf"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+interface VirtualItem {
+    index: number;
+    position: number;
+}
+export declare class Virtualizer<T> {
+    private readonly containerRef;
+    readonly virtualFor: import("@angular/core").Signal<VirtualFor<T>>;
+    readonly itemSize: import("@angular/core").InputSignalWithTransform<number, unknown>;
+    readonly buffer: import("@angular/core").InputSignal<number>;
+    readonly orientation: import("@angular/core").InputSignal<Orientation>;
+    private readonly scrollPosition;
+    private readonly containerSize;
+    readonly items: import("@angular/core").Signal<T[]>;
+    private readonly totalItems;
+    readonly totalContentSize: import("@angular/core").Signal<number>;
+    readonly isVertical: import("@angular/core").Signal<boolean>;
+    private readonly visibleIndexes;
+    readonly visibleItems: import("@angular/core").Signal<VirtualItem[]>;
+    private readonly client;
+    constructor();
+    getTransform(item: VirtualItem): string;
+    onScroll(event: UIEvent): void;
+    onKeyDown(event: KeyboardEvent): void;
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    private updateContainerSize;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Virtualizer<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Virtualizer<any>, "ngb-virtualizer, [ngbVirtualizer]", never, { "itemSize": { "alias": "itemSize"; "required": true; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, ["virtualFor"], never, true, never>;
+}
+export {};