@apexara/ng-components 1.0.0

package/types/apexara-ng-components-listbox.d.ts

@@ -0,0 +1,70 @@
+import * as i0 from '@angular/core';
+import { ElementRef, ChangeDetectorRef, EventEmitter, SimpleChanges } from '@angular/core';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { FormGroup, AbstractControl } from '@angular/forms';
+import { Subscription } from 'rxjs';
+import { IpiSelectData } from '@apexara/ng-components/select';
+import { IpiControlErrors } from '@apexara/ng-components/input';
+import { TooltipPosition } from '@apexara/ng-components/tooltip';
+
+interface IpiListBoxOptions {
+    data: IpiSelectData[];
+    label?: string;
+    tooltip?: string;
+    formGroup?: FormGroup;
+    formControlName?: string;
+    errors?: IpiControlErrors;
+}
+declare class IpiListboxComponent {
+    private elementRef;
+    private changeDetectorRef;
+    constructor(elementRef: ElementRef, changeDetectorRef: ChangeDetectorRef);
+    listbox: ElementRef<HTMLDivElement> | null;
+    cdkViewport?: CdkVirtualScrollViewport;
+    options: IpiListBoxOptions;
+    virtualScroll: boolean;
+    itemSize: number;
+    selectChange: EventEmitter<IpiSelectData[]>;
+    tooltipPosition: typeof TooltipPosition;
+    controlError: string;
+    controlInvalid: boolean;
+    control: AbstractControl | null;
+    controlSubscription: Subscription | null;
+    private documentKeyupValue;
+    private documentKeyupValueResetTime;
+    private documentKeyDownSubscription;
+    private isMetaHold;
+    private isShiftHold;
+    private listHeight;
+    private lastSelectedItemIndex;
+    private lastSelectedItemIndexOnShiftHold;
+    private dragSelecting;
+    private dragAnchorIndex;
+    private selectedItems;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    mousedown(index: number): void;
+    mouseup(): void;
+    keyup(event: KeyboardEvent): void;
+    mouseover(index: number): void;
+    private keydown;
+    private documentArrowsKeyup;
+    private documentKeyup;
+    private addSelectedItems;
+    private removeSelectedItems;
+    private clearAllSelections;
+    isIndexSelected(index: number): boolean;
+    trackByIndex(index: number): number;
+    private scrollIndexIntoView;
+    shouldShowViewportScroll(): boolean;
+    private getControl;
+    private checkIfControlInvalid;
+    private getControlError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiListboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiListboxComponent, "ipi-listbox", never, { "options": { "alias": "options"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "itemSize": { "alias": "itemSize"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+}
+
+export { IpiListboxComponent };
+export type { IpiListBoxOptions };

package/types/apexara-ng-components-radiobutton.d.ts

@@ -0,0 +1,30 @@
+import * as i0 from '@angular/core';
+import { EventEmitter } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { TooltipPosition } from '@apexara/ng-components/tooltip';
+
+interface IpiRadioData {
+    label: string;
+    value: any;
+    tooltip?: string;
+    isHover?: boolean;
+}
+interface IpiRadioButtonOptions {
+    checked?: number;
+    inline?: boolean;
+    data: IpiRadioData[];
+    formGroup?: FormGroup;
+    formControlName?: string;
+}
+declare class IpiRadioButtonComponent {
+    options: IpiRadioButtonOptions;
+    selectChange: EventEmitter<IpiRadioData>;
+    buttonGroupId: number;
+    tooltipPositionAbove: TooltipPosition;
+    onChange(item: IpiRadioData): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiRadioButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiRadioButtonComponent, "ipi-radio-button", never, { "options": { "alias": "options"; "required": false; }; }, { "selectChange": "selectChange"; }, never, never, true, never>;
+}
+
+export { IpiRadioButtonComponent };
+export type { IpiRadioButtonOptions, IpiRadioData };

package/types/apexara-ng-components-select.d.ts

@@ -0,0 +1,111 @@
+import * as i0 from '@angular/core';
+import { OnInit, AfterViewInit, OnDestroy, ElementRef, EventEmitter, IterableDiffers, ChangeDetectorRef, SimpleChanges } from '@angular/core';
+import { FormGroup, AbstractControl } from '@angular/forms';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { OSService } from '@apexara/ng-components/services';
+import { TooltipPosition } from '@apexara/ng-components/tooltip';
+
+interface IpiSelectOptions {
+    label: string;
+    tooltip?: string;
+    data: IpiSelectData[];
+    multiple?: boolean;
+    counterAsValue?: boolean;
+    placeholder?: string;
+    helperText?: string;
+    helperRoute?: string;
+    prefixImg?: string;
+    suffixImg?: string;
+    formGroup?: FormGroup;
+    searchable?: boolean;
+    formControlName?: string;
+    errors?: ControlErrors;
+    maxDropdownHeightPx?: number;
+}
+interface IpiSelectData {
+    label: string;
+    value: any;
+    description?: string;
+    isHover?: boolean;
+}
+interface ControlErrors {
+    [x: string]: string;
+}
+declare class IpiSelectComponent implements OnInit, AfterViewInit, OnDestroy {
+    private osService;
+    private elementRef;
+    private iterableDiffers;
+    private changeDetectorRef;
+    input: ElementRef<HTMLInputElement> | null;
+    label: ElementRef<HTMLLabelElement> | null;
+    dropdown: CdkVirtualScrollViewport | null;
+    inputWrapper: ElementRef<HTMLInputElement> | null;
+    options: IpiSelectOptions;
+    selectChange: EventEmitter<IpiSelectData>;
+    helperTextChange: EventEmitter<void>;
+    constructor(osService: OSService, elementRef: ElementRef, iterableDiffers: IterableDiffers, changeDetectorRef: ChangeDetectorRef);
+    firstDropdown: number;
+    isDropdown: boolean;
+    control: AbstractControl;
+    tooltipPosition: typeof TooltipPosition;
+    private platformId;
+    private isDropdownReversed;
+    private shouldPreventEvents;
+    private documentKeyupValue;
+    private documentKeyupValueResetTime;
+    private documentKeyUpSubscription;
+    private dataDiffer;
+    private controlSubscription;
+    filteredData: IpiSelectData[];
+    private lastSearch;
+    private keyListener;
+    private wheelListener;
+    private scrollBlockersAttached;
+    optionItemSizePx: number;
+    maxVisibleOptions: number;
+    dropdownHeightPx: number;
+    ngOnInit(): void;
+    ngDoCheck(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    onHelperText(): void;
+    setValue(value: any): void;
+    setMultipleValue(data: any, event?: Event): void;
+    setVisibleValue(newValue: any | any[]): void;
+    private updateDropdownHeight;
+    showMultipleCount(): number;
+    isValueSelected(value: IpiSelectData): boolean;
+    isMultipleSelected(value: IpiSelectData): boolean;
+    activateDropdown(): void;
+    deactivateControl(event: MouseEvent | KeyboardEvent): void;
+    onFocusIn(): void;
+    onFocusOut(): void;
+    toggleDropdown(): void;
+    private generateDropdownPosition;
+    removeDropdown(): void;
+    handleKeydown(event: any): void;
+    preventFocusChange(event: MouseEvent): void;
+    onSearch(value: string, shouldResetHover?: boolean): void;
+    getPlaceholder(): string;
+    checkIfControlInvalid(): boolean;
+    checkIfControlDisabled(): boolean;
+    private getControl;
+    private isWithinBounds;
+    private handleEvents;
+    private keyup;
+    private documentEnterKeyup;
+    private documentArrowsKeyup;
+    private documentKeyup;
+    private removeProperty;
+    private blockArrowScroll;
+    private blockScroll;
+    private isDescendant;
+    private attachGlobalScrollBlockers;
+    private detachGlobalScrollBlockers;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiSelectComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiSelectComponent, "ipi-select", never, { "options": { "alias": "options"; "required": false; }; }, { "selectChange": "selectChange"; "helperTextChange": "helperTextChange"; }, never, never, true, never>;
+}
+
+export { IpiSelectComponent };
+export type { ControlErrors, IpiSelectData, IpiSelectOptions };

package/types/apexara-ng-components-services.d.ts

@@ -0,0 +1,96 @@
+import * as i0 from '@angular/core';
+import { Injector, ViewContainerRef } from '@angular/core';
+import { FocusTrapFactory } from '@angular/cdk/a11y';
+
+declare class UserAgentService {
+    private platformId;
+    constructor(platformId: Object);
+    private userAgent;
+    getUserAgent(): string | undefined;
+    private init;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserAgentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserAgentService>;
+}
+
+declare enum MobileOS {
+    iOS = 0,
+    Android = 1,
+    WindowsPhone = 2,
+    Other = 3
+}
+declare class OSService {
+    private userAgentService;
+    constructor(userAgentService: UserAgentService);
+    mobileOS: MobileOS;
+    private getMobileOS;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OSService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OSService>;
+}
+
+declare enum Theme {
+    First = 0,
+    Second = 1,
+    Third = 2
+}
+declare class ThemeService {
+    private currentTheme;
+    setTheme(theme: Theme): void;
+    getTheme(): Theme;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ThemeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ThemeService>;
+}
+
+declare class ScrollBlockService {
+    private isActivated;
+    private previousStyles;
+    activate(): void;
+    deactivate(): void;
+    private getPreviousStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScrollBlockService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ScrollBlockService>;
+}
+
+declare class OverlayService {
+    private injector;
+    private focusTrapFactory;
+    private scrollBlockService;
+    private document;
+    constructor(injector: Injector, focusTrapFactory: FocusTrapFactory, scrollBlockService: ScrollBlockService, document: Document);
+    private focusTrap;
+    private blockActivated;
+    private overlayElement;
+    private overlayChildren;
+    get overlay(): HTMLElement | null;
+    appendToOverlay(content: HTMLElement, blockable?: boolean): void;
+    removeFromOverlay(content: HTMLElement): void;
+    private createOverlay;
+    private removeOverlay;
+    static ɵfac: i0.ɵɵFactoryDeclaration<OverlayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<OverlayService>;
+}
+
+declare class LoaderService {
+    private overlayService;
+    constructor(overlayService: OverlayService);
+    private viewContainerRef;
+    private appContainerElement;
+    private loaderRef;
+    /**
+     * Call this method globally in order to set a more global ViewContainerRef
+     * @param viewContainerRef - the Host Container Ref where we want the Loader to be attached. i.e the App Component or Layout Component
+     * @param appContainerElement - An optional app container selector. When provided it will set opacity 0.4 to that container when Loader is shown. Example - '.app-container'
+     */
+    init(viewContainerRef: ViewContainerRef, appContainerElement?: string): void;
+    show(): void;
+    hide(): void;
+    private setAppContainerOpacity;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoaderService>;
+}
+
+declare class IpiLoaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiLoaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiLoaderComponent, "ipi-loader", never, {}, {}, never, never, true, never>;
+}
+
+export { IpiLoaderComponent, LoaderService, MobileOS, OSService, OverlayService, ScrollBlockService, Theme, ThemeService };

package/types/apexara-ng-components-snackbar.d.ts

@@ -0,0 +1,73 @@
+import * as i0 from '@angular/core';
+import { ElementRef, EventEmitter, ApplicationRef } from '@angular/core';
+import { OverlayService } from '@apexara/ng-components/services';
+
+declare enum VerticalPosition {
+    Bottom = 0,
+    Top = 1
+}
+declare enum HorizontalPosition {
+    Left = 0,
+    Center = 1,
+    Right = 2
+}
+interface IpiSnackbarOptions {
+    title?: string;
+    icon?: string;
+    error: boolean;
+    shouldClose: boolean;
+    duration: number;
+    animationDuration: number;
+    position: SnackbarPosition;
+    backgroundColor: string;
+    errorBackgroundColor: string;
+    progressColor: string;
+    placeholderTextColor: string;
+    messageTextColor: string;
+    xIconColor: string;
+}
+interface SnackbarPosition {
+    horizontalPosition?: HorizontalPosition;
+    verticalPosition?: VerticalPosition;
+}
+declare class IpiSnackbarComponent {
+    container: ElementRef<HTMLDivElement>;
+    message: String;
+    options: IpiSnackbarOptions;
+    positionOptions: SnackbarPosition;
+    closing: boolean;
+    closed: EventEmitter<void>;
+    ngAfterViewInit(): void;
+    getAnimationParams(): {
+        duration: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiSnackbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiSnackbarComponent, "ipi-snackbar", never, { "message": { "alias": "message"; "required": false; }; "options": { "alias": "options"; "required": false; }; "positionOptions": { "alias": "positionOptions"; "required": false; }; "closing": { "alias": "closing"; "required": false; }; }, { "closed": "closed"; }, never, never, true, never>;
+}
+
+declare class IpiSnackbarService {
+    private appRef;
+    private overlayService;
+    constructor(appRef: ApplicationRef, overlayService: OverlayService);
+    private maxSnackbars;
+    private snackbarContainerMap;
+    private defaultSnackbarOptions;
+    private snackbarsArray;
+    open(message?: string, options?: Partial<IpiSnackbarOptions>, component?: unknown, data?: Record<string, unknown>): void;
+    setMaxSnackbars(length: number): void;
+    updateDefaultOptions(options: Partial<IpiSnackbarOptions>): void;
+    private createSnackbarContainer;
+    private createComponent;
+    private applySnackbarStyles;
+    private closeIfMaxSnackbar;
+    private subscribeToClosingEvents;
+    private applySnackbarContainerStyles;
+    private close;
+    private generateSnackbarContainerId;
+    private findSnackbarElementIndexFromRef;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiSnackbarService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IpiSnackbarService>;
+}
+
+export { HorizontalPosition, IpiSnackbarComponent, IpiSnackbarService, VerticalPosition };
+export type { IpiSnackbarOptions, SnackbarPosition };

package/types/apexara-ng-components-table.d.ts

@@ -0,0 +1,157 @@
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, ElementRef, QueryList, TemplateRef, EventEmitter, SimpleChanges } from '@angular/core';
+import { CdkVirtualScrollViewport } from '@angular/cdk/scrolling';
+import { FormBuilder, FormGroup, FormControl } from '@angular/forms';
+import { IpiSelectOptions } from '@apexara/ng-components/select';
+import { OSService } from '@apexara/ng-components/services';
+import { TooltipPosition } from '@apexara/ng-components/tooltip';
+
+interface IpiTableColumn {
+    label?: string;
+    value?: string;
+    type?: IpiTableColumnType;
+    width?: string;
+    editable?: boolean;
+    prefix?: string;
+    suffix?: string;
+    singleActions?: Action[];
+    multipleActions?: Action[];
+    dateFormat?: IpiDateFormatOptions;
+    chipLabel?: {
+        [key: string]: string;
+    };
+    class?: string | {
+        [key: string]: string;
+    };
+}
+declare enum IpiTableColumnType {
+    Text = 0,
+    Date = 1,
+    Currency = 2,
+    Chip = 3,
+    Number = 4,
+    NumberMath = 5,
+    Actions = 6,
+    Checkbox = 7
+}
+type ActionShowType = Array<{
+    property: string;
+    values: any[];
+    exists?: boolean;
+}>;
+interface Action {
+    icon: string;
+    label: string;
+    class?: string;
+    showOn?: ActionShowType;
+    disabled?: boolean;
+    execute?: (row: any) => void;
+}
+interface IpiTableChange {
+    from: number;
+    to: number;
+    filter?: string;
+    sort?: any;
+}
+interface IpiDateFormatOptions {
+    format: string;
+    locale: string;
+    timezone?: string;
+}
+interface PageFormControls {
+    pageSize: FormControl<{
+        label: string;
+        value: number;
+    }>;
+}
+declare class IpiTableComponent {
+    private osService;
+    private formBuilder;
+    private changeDetectorRef;
+    constructor(osService: OSService, formBuilder: FormBuilder, changeDetectorRef: ChangeDetectorRef);
+    theadRef?: ElementRef<HTMLElement>;
+    moreActionsList: QueryList<ElementRef>;
+    cdkViewport?: CdkVirtualScrollViewport;
+    DropdownElement: ElementRef<any> | null;
+    textCellTpl: TemplateRef<any>;
+    numberCellTpl: TemplateRef<any>;
+    currencyCellTpl: TemplateRef<any>;
+    numberMathCellTpl: TemplateRef<any>;
+    dateCellTpl: TemplateRef<any>;
+    chipCellTpl: TemplateRef<any>;
+    checkboxCellTpl: TemplateRef<any>;
+    actionCellTpl: TemplateRef<any>;
+    data: any[];
+    dataLength: number;
+    columns: IpiTableColumn[];
+    filter: string;
+    serverSide: boolean;
+    isLoading: boolean;
+    sortIndex: number;
+    sortable: boolean;
+    sortDirection: 'asc' | 'desc';
+    pageSize: number;
+    currentPage: number;
+    pageable: boolean;
+    pageSizeOptions: number[];
+    virtualScroll: boolean;
+    tableMaxHeight: number;
+    tableChange: EventEmitter<IpiTableChange>;
+    itemSize: number;
+    tooltipPosition: typeof TooltipPosition;
+    TableColumnType: typeof IpiTableColumnType;
+    totalPages: number;
+    visibleRange: string;
+    filteredData: any[];
+    pageSizeSelectOptions: IpiSelectOptions;
+    currentActiveRow: any;
+    isDropdown: boolean;
+    formGroup: FormGroup<PageFormControls>;
+    private _dataLength;
+    onClick(event: any): void;
+    onScroll(): void;
+    onResize(): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    getPageData(): any[];
+    updateVisibleRange(start: number, end: number): void;
+    calculateTotalPages(): void;
+    trackByIndex(index: number): number;
+    getVirtualViewportHeight(): number;
+    shouldShowViewportScroll(): boolean;
+    getCellTemplate(column: IpiTableColumn): TemplateRef<any>;
+    private refreshLayout;
+    goToPage(page: number): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+    goToFirstPage(): void;
+    goToLastPage(): void;
+    cellEdit(event: KeyboardEvent, column: string, currentPageRowIndex: number): void;
+    formatDate(dateAsString: string | null | undefined, formatDateOptions?: IpiDateFormatOptions): string;
+    getClass(row: any, column: IpiTableColumn): {
+        [key: string]: boolean;
+    } | string;
+    getDescendantProp(row: any, column: IpiTableColumn): any;
+    getChipLabel(row: any, column: IpiTableColumn): string;
+    getCheckboxState(row: any, column: IpiTableColumn): boolean;
+    handleActionShow(action: Action, row: any, column?: IpiTableColumn): boolean;
+    sortColumn(column: any, changeSortDirection?: boolean): void;
+    toggleActionDropdown(row: any, event: any): Promise<void>;
+    onViewportScroll(): void;
+    private preprocessData;
+    private calculateNumberMathCell;
+    private filterData;
+    private sortData;
+    private sortByProperty;
+    private sortReverse;
+    private getAccessIfColumnValueIsObject;
+    private buildPaginationSelectDependecies;
+    private subscribeToFormValueChanges;
+    private calculatePages;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiTableComponent, "ipi-table", never, { "data": { "alias": "data"; "required": false; }; "dataLength": { "alias": "dataLength"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "serverSide": { "alias": "serverSide"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "sortIndex": { "alias": "sortIndex"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "sortDirection": { "alias": "sortDirection"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; "pageable": { "alias": "pageable"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "tableMaxHeight": { "alias": "tableMaxHeight"; "required": false; }; }, { "tableChange": "tableChange"; }, never, never, true, never>;
+}
+
+export { IpiTableColumnType, IpiTableComponent };
+export type { Action, ActionShowType, IpiDateFormatOptions, IpiTableChange, IpiTableColumn };

package/types/apexara-ng-components-textarea.d.ts

@@ -0,0 +1,34 @@
+import * as i0 from '@angular/core';
+import { ChangeDetectorRef, EventEmitter } from '@angular/core';
+import { FormGroup, AbstractControl } from '@angular/forms';
+import { IpiControlErrors } from '@apexara/ng-components/input';
+
+interface IpiTextAreaOptions {
+    label: string;
+    icon?: string;
+    placeholder?: string;
+    formGroup?: FormGroup;
+    formControlName?: string;
+    errors?: IpiControlErrors;
+}
+declare class IpiTextAreaComponent {
+    private changeDetectorRef;
+    constructor(changeDetectorRef: ChangeDetectorRef);
+    options: IpiTextAreaOptions;
+    textAreaChange: EventEmitter<string>;
+    controlError: string;
+    controlInvalid: boolean;
+    control: AbstractControl;
+    private controlSubscription;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onInput(event: Event): void;
+    private setControl;
+    private setControlInvalid;
+    private getErrors;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiTextAreaComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<IpiTextAreaComponent, "ipi-textarea", never, { "options": { "alias": "options"; "required": false; }; }, { "textAreaChange": "textAreaChange"; }, never, never, true, never>;
+}
+
+export { IpiTextAreaComponent };
+export type { IpiTextAreaOptions };

package/types/apexara-ng-components-tooltip.d.ts

@@ -0,0 +1,54 @@
+import * as i0 from '@angular/core';
+import { ElementRef } from '@angular/core';
+import { OSService, OverlayService } from '@apexara/ng-components/services';
+
+declare enum TooltipPosition {
+    Before = 0,
+    After = 1,
+    Above = 2,
+    Below = 3
+}
+declare class IpiTooltipDirective {
+    private osService;
+    private elementRef;
+    private overlayService;
+    private document;
+    constructor(osService: OSService, elementRef: ElementRef, overlayService: OverlayService, document: Document);
+    ipiTooltip: string;
+    tooltipPosition: TooltipPosition;
+    private platform;
+    private tooltip;
+    private triangle;
+    private tooltipWrapper;
+    private isActivated;
+    private longPressTimeout;
+    private longPressDelay;
+    private triangleWidth;
+    private tooltipWidth;
+    private parentElementPos;
+    private errorMargin;
+    ngOnDestroy(): void;
+    onMouseEnter(): void;
+    onMouseLeave(): void;
+    onResize(): void;
+    onTouchStart(event: TouchEvent): void;
+    onTouchEnd(): void;
+    onTouchCancel(): void;
+    onScroll(): void;
+    private getParentElementPosition;
+    private openToolTip;
+    private closeToolTip;
+    private createTooltip;
+    private createTriangle;
+    private createTooltipWrapper;
+    private positionTooltip;
+    private positionBefore;
+    private positionAfter;
+    private positionAbove;
+    private positionBelow;
+    private repositionTooltip;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IpiTooltipDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<IpiTooltipDirective, "[ipiTooltip]", never, { "ipiTooltip": { "alias": "ipiTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { IpiTooltipDirective, TooltipPosition };

package/types/apexara-ng-components.d.ts

@@ -0,0 +1,3 @@
+declare const NG_COMPONENTS = "@apexara/ng-components";
+
+export { NG_COMPONENTS };