@haloduck/ui/index.d.ts

HaloDuck UI Library - Angular

import { HttpClient } from '@angular/common/http';
import { FormGroup, FormBuilder, ControlValueAccessor } from '@angular/forms';
import * as i0 from '@angular/core';
import { EventEmitter, AfterViewInit, OnChanges, ElementRef, SimpleChanges, OnInit, OnDestroy, Type, Renderer2, Injector, TemplateRef } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, Subject } from 'rxjs';
import { LngLat, MenuItemEx, SearchParams, TableRowProperty } from '@haloduck/core';
import { SafeHtml, DomSanitizer } from '@angular/platform-browser';
import * as THREE from 'three';
import { STLLoader, OrbitControls } from 'three-stdlib';
import * as _haloduck_ui from '@haloduck/ui';
import { OverlayRef, Overlay } from '@angular/cdk/overlay';
import * as _jsverse_transloco from '@jsverse/transloco';

declare class AuthenticateComponent {
    private fb;
    private http;
    private notificationService;
    loginForm: FormGroup;
    signupForm: FormGroup;
    resetForm: FormGroup;
    newPasswordForm: FormGroup;
    otpForm: FormGroup;
    stage: 'login' | 'signup' | 'reset' | 'newPassword' | 'otpVerify';
    emailForReset: string;
    constructor(fb: FormBuilder, http: HttpClient);
    switchStage(stage: 'login' | 'signup' | 'reset' | 'newPassword' | 'otpVerify'): void;
    login(): void;
    confirmNewPassword(): void;
    signup(): void;
    reset(): void;
    verifyOtp(): void;
    get passwordValue(): string;
    get isMinLength(): boolean;
    get hasUppercase(): boolean;
    get hasLowercase(): boolean;
    get hasNumber(): boolean;
    get hasSpecialChar(): boolean;
    get isPasswordValid(): boolean;
    get passwordRules(): {
        label: string;
        valid: boolean;
    }[];
    static ɵfac: i0.ɵɵFactoryDeclaration<AuthenticateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<AuthenticateComponent, "haloduck-authenticate", never, {}, {}, never, never, true, never>;
}

type ButtonVariant = 'primary' | 'secondary' | 'danger' | 'none';
declare class ButtonComponent {
    disabled: boolean | null;
    variant: ButtonVariant;
    static ɵfac: i0.ɵɵFactoryDeclaration<ButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ButtonComponent, "haloduck-button", never, { "disabled": { "alias": "disabled"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface Option {
    id?: string;
    value: string;
    isSticky?: boolean;
    isExclusive?: boolean;
    shouldManualInput?: boolean;
    manualPrefix?: string;
}
declare class SelectDropdownComponent {
    protected _filteredOptions: i0.WritableSignal<Option[]>;
    protected _options: Option[];
    protected _selectedOptionIds: string[];
    protected manualInputValues: Record<string, string>;
    protected activeManualKey: string | null;
    selectedChange: EventEmitter<string[]>;
    closeDropdown: EventEmitter<void>;
    useFilter: boolean;
    multiselect: boolean;
    atLeastOne: boolean;
    asButton: boolean;
    set options(value: Option[] | null);
    get options(): Option[] | null;
    set selectedOptionIds(value: string[] | null);
    get selectedOptions(): string[] | null;
    onFilterInput(event: Event): void;
    onToggleOption(option: Option): void;
    isOptionSelected(option: Option): boolean;
    private isIdExclusive;
    private getManualKey;
    private seedManualInputs;
    onManualInputChange(option: Option, value: string): void;
    onManualInputConfirm(option: Option): void;
    onManualInputBlur(option: Option): void;
    private emitSelectedChange;
    private setSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectDropdownComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectDropdownComponent, "haloduck-select-dropdown", never, { "useFilter": { "alias": "useFilter"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "atLeastOne": { "alias": "atLeastOne"; "required": false; }; "asButton": { "alias": "asButton"; "required": false; }; "options": { "alias": "options"; "required": false; }; "selectedOptionIds": { "alias": "selectedOptionIds"; "required": false; }; }, { "selectedChange": "selectedChange"; "closeDropdown": "closeDropdown"; }, never, never, true, never>;
}

declare class SelectComponent implements ControlValueAccessor, AfterViewInit, OnChanges {
    private readonly translateService;
    private readonly overlay;
    private readonly viewContainerRef;
    private readonly cdr;
    private overlayRef;
    selectedChange: EventEmitter<string | string[]>;
    disabled: boolean | null;
    loading: boolean;
    variant: 'primary' | 'secondary' | 'danger' | 'none';
    asButton: boolean;
    useIcon: boolean;
    useFilter: boolean;
    multiselect: boolean;
    placeholder: string;
    atLeastOne: boolean;
    showAll: boolean;
    options: Option[] | null;
    layout: 'horizontal' | 'vertical';
    labelWidth: string;
    set value(value: string[] | string);
    get value(): string | string[] | null;
    origin: ElementRef;
    label: ElementRef;
    isDropdownOpen: i0.WritableSignal<boolean>;
    selectedOptionIds: string[];
    displayedSelectedOptions: Option[];
    private selectedIdToDisplayOption;
    onClick(event: MouseEvent): void;
    onKeyDown(event: KeyboardEvent): void;
    onDeselectOption(event: Event, option: Option): void;
    getSelectedValue(): string | string[] | null;
    onChange: (_value: any) => void;
    onTouched: () => void;
    writeValue(value: string[] | string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngAfterViewInit(): void;
    constructor();
    ngOnChanges(changes: SimpleChanges): void;
    private recomputeSelectedOptions;
    private isManualSelection;
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SelectComponent, "haloduck-select", never, { "disabled": { "alias": "disabled"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "asButton": { "alias": "asButton"; "required": false; }; "useIcon": { "alias": "useIcon"; "required": false; }; "useFilter": { "alias": "useFilter"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "atLeastOne": { "alias": "atLeastOne"; "required": false; }; "showAll": { "alias": "showAll"; "required": false; }; "options": { "alias": "options"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "labelWidth": { "alias": "labelWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "selectedChange": "selectedChange"; }, never, ["*", "buttonIcon"], true, never>;
}

interface DateRange {
    from: string;
    to: string;
}
interface DateRangeDropdown {
    currentYear: number;
    currentMonth: number;
    from?: string;
    listCalendarDate: CalendarDate[];
}
interface CalendarDate {
    datetime: string;
    date: string;
    isToday: boolean;
    isTheDate: boolean;
    isCurrentMonth: boolean;
}
declare class CalendarComponent implements OnInit {
    private readonly translateService;
    monthSelect: SelectComponent;
    singleDate: boolean;
    firstDayOfWeek: number;
    selectedDate?: string;
    selectedDateRange?: DateRange;
    dateChange: EventEmitter<CalendarDate>;
    dateRangeChange: EventEmitter<DateRange>;
    currentYear: number;
    currentMonth: number;
    listCalendarDate: CalendarDate[];
    isFromSelected: boolean;
    yearList: Option[];
    monthList: Option[];
    onAdjustYear(amount: number): void;
    onAdjustMonth(amount: number): void;
    onSelectCalendarDate(date: CalendarDate): void;
    onCalenderOpen(value: string | DateRange): void;
    calculateDateRangeDropdown(): void;
    onSelectYear(year: string | string[]): void;
    onSelectMonth(month: string | string[]): void;
    ngOnInit(): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CalendarComponent, "haloduck-calendar", never, { "singleDate": { "alias": "singleDate"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "selectedDate": { "alias": "selectedDate"; "required": false; }; "selectedDateRange": { "alias": "selectedDateRange"; "required": false; }; }, { "dateChange": "dateChange"; "dateRangeChange": "dateRangeChange"; }, never, never, true, never>;
}
declare function dateToString(date: Date): string;

interface Button {
    id: string;
    label: string;
    variant: ButtonVariant;
}

declare class ConfirmDialogService {
    private readonly dialogService;
    private clickedButton$;
    confirm(title: string, message: string, buttons: Button[]): Observable<string>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ConfirmDialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ConfirmDialogService>;
}

declare class CopyButtonComponent {
    text: string;
    isAnimating: boolean;
    copyToClipboard($event: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CopyButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<CopyButtonComponent, "haloduck-copy-button", never, { "text": { "alias": "text"; "required": false; }; }, {}, never, never, true, never>;
}

declare class DatePickerComponent implements ControlValueAccessor, OnInit, OnDestroy {
    destroy$: Subject<void>;
    private readonly translateService;
    private readonly overlay;
    disabled: boolean;
    placeholder: string;
    firstDayOfWeek: number;
    origin: ElementRef;
    selectedDate?: string;
    private overlayRef?;
    onClick(): void;
    onDateChange(date: CalendarDate): void;
    openCalendar(): void;
    closeCalendar(): void;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: string): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DatePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatePickerComponent, "haloduck-date-picker", never, { "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class DateRangeComponent implements ControlValueAccessor, OnDestroy {
    destroy$: Subject<void>;
    private readonly translateService;
    private readonly overlay;
    dateRangeOptions: Option[];
    disabled: boolean;
    placeholder: string;
    firstDayOfWeek: number;
    origin: ElementRef;
    selectedDateRangeOptionId?: string;
    dateRange?: DateRange;
    private overlayRef?;
    getSelectedDateRangeString(): any;
    onClick(): void;
    onDateRangeOptionChange(selectedOptionId: string): void;
    onDateRangeChange(dateRange: DateRange): void;
    calculateDateRange(): void;
    getDateRangeOptionId(dateRange: DateRange): string;
    openCalendar(): void;
    closeCalendar(): void;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: DateRange): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    ngOnDestroy(): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<DateRangeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DateRangeComponent, "haloduck-date-range", never, { "dateRangeOptions": { "alias": "dateRangeOptions"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class DrawCanvasComponent implements AfterViewInit, ControlValueAccessor {
    imagePath: string;
    lineColor: string;
    canvasRef: ElementRef<HTMLCanvasElement>;
    private ctx;
    private isDrawing;
    private onChange;
    private onTouched;
    ngAfterViewInit(): void;
    private loadImage;
    private setupCanvas;
    private startMouseDrawing;
    private mouseDraw;
    private startTouchDrawing;
    private touchDraw;
    private stopDrawing;
    saveDrawing(): void;
    private dataURLToBlob;
    writeValue(file: File | null): void;
    registerOnChange(fn: (file: File | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    onReset(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DrawCanvasComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DrawCanvasComponent, "haloduck-draw-canvas", never, { "imagePath": { "alias": "imagePath"; "required": false; }; "lineColor": { "alias": "lineColor"; "required": false; }; }, {}, never, never, true, never>;
}

declare const ERROR_NOT_ACCEPTABLE_FILE_TYPE = "NOT_ACCEPTABLE_FILE_TYPE";
declare const ERROR_OVER_SIZE = "OVER_SIZE";
declare const ERROR_OVER_COUNT = "OVER_COUNT";
declare const ERROR_UPLOAD = "UPLOAD";
interface FileEx extends File {
    isUploading: boolean;
    isUploaded: boolean;
    key: string;
    name: string;
    size: number;
    type: string;
    tag: string[];
    previewUrl?: string;
}
declare class FileUploaderComponent implements ControlValueAccessor {
    disabled: boolean;
    urlPrefix: string;
    keyPrefix: string;
    uploadApi: (file: File, keyPrefix: string) => Observable<string>;
    multiple: boolean;
    maxCount: number;
    maxSize: number;
    accept: string[];
    filesAdded: EventEmitter<FileEx[]>;
    fileRemoved: EventEmitter<FileEx>;
    error: EventEmitter<{
        error: string;
        file: FileEx;
    }[]>;
    private readonly cdr;
    private readonly zone;
    files: FileEx[];
    isUploading: boolean;
    isDragOver: boolean;
    private onChange;
    private onTouched;
    writeValue(files: FileEx[]): void;
    registerOnChange(fn: (files: FileEx[]) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    onFileSelected(event: Event): void;
    removeFile(index: number): void;
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    onDrop(event: DragEvent): void;
    getFilePreview(file: FileEx): string;
    addFiles(addedFiles: FileEx[]): void;
    isAcceptableFileType(file: File): boolean;
    startUpload(): Observable<FileEx[]>;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileUploaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileUploaderComponent, "haloduck-file-uploader", never, { "disabled": { "alias": "disabled"; "required": false; }; "urlPrefix": { "alias": "urlPrefix"; "required": false; }; "keyPrefix": { "alias": "keyPrefix"; "required": false; }; "uploadApi": { "alias": "uploadApi"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "maxCount": { "alias": "maxCount"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; }, { "filesAdded": "filesAdded"; "fileRemoved": "fileRemoved"; "error": "error"; }, never, never, true, never>;
}

declare class FlipComponent {
    title: string;
    set isOpen(value: boolean);
    _isOpen: i0.WritableSignal<boolean>;
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FlipComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FlipComponent, "haloduck-flip", never, { "title": { "alias": "title"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class ImageUploaderComponent implements ControlValueAccessor, OnInit {
    disabled: boolean;
    id: string;
    alt: string;
    urlPrefix: string;
    keyPrefix: string;
    uploadApi: (file: File, keyPrefix: string) => Observable<string>;
    backgroundImage: string;
    shouldPassToSibling: boolean;
    passToSibling: EventEmitter<FileEx[]>;
    fileAdded: EventEmitter<FileEx>;
    fileRemoved: EventEmitter<FileEx>;
    error: EventEmitter<{
        error: string;
        file: FileEx;
    }[]>;
    imageUrl: string | null;
    file: FileEx | null;
    isDragOver: boolean;
    isUploading: boolean;
    private readonly dialogService;
    private onChange;
    private onTouched;
    writeValue(key: string | null): void;
    registerOnChange(fn: (url: string | null) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    startUpload(): Observable<FileEx>;
    onFileSelected(event: Event): void;
    onDrop(event: DragEvent): void;
    onDragOver(event: DragEvent): void;
    onDragLeave(event: DragEvent): void;
    onDragStart(event: DragEvent): void;
    onDragEnd(event: DragEvent): void;
    removeImage(): void;
    setFiles(listFile: FileEx[]): void;
    previewImage(imageUrl: string): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageUploaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageUploaderComponent, "haloduck-image-uploader", never, { "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "urlPrefix": { "alias": "urlPrefix"; "required": false; }; "keyPrefix": { "alias": "keyPrefix"; "required": false; }; "uploadApi": { "alias": "uploadApi"; "required": false; }; "backgroundImage": { "alias": "backgroundImage"; "required": false; }; "shouldPassToSibling": { "alias": "shouldPassToSibling"; "required": false; }; }, { "passToSibling": "passToSibling"; "fileAdded": "fileAdded"; "fileRemoved": "fileRemoved"; "error": "error"; }, never, ["*"], true, never>;
}

declare class ImageViewerComponent {
    context: any;
    imageUrl: string;
    imageAlt: string;
    private readonly dialogService;
    onClose(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ImageViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ImageViewerComponent, "haloduck-image-viewer", never, { "context": { "alias": "context"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "imageAlt": { "alias": "imageAlt"; "required": false; }; }, {}, never, never, true, never>;
}

declare class InputComponent implements ControlValueAccessor, AfterViewInit {
    private readonly cdr;
    label: ElementRef;
    private inputElement;
    placeholder: string;
    type: string;
    disabled: boolean;
    rows: number;
    autofocus: boolean;
    value: string;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    focus(): void;
    onInput(event: Event): void;
    onKeydown($event: KeyboardEvent): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<InputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<InputComponent, "haloduck-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "autofocus": { "alias": "autofocus"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class LanguageSelectorComponent implements OnInit {
    origin: ElementRef;
    private readonly destroy$;
    private readonly translateService;
    private readonly overlay;
    language: i0.WritableSignal<string>;
    private overlayRef?;
    showLanguageOptions(): void;
    hideLanguageOptions(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<LanguageSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<LanguageSelectorComponent, "haloduck-language-selector", never, {}, {}, never, never, true, never>;
}

declare const google: any;
interface Location {
    plusCode: string;
    postalCode: string;
    countryCode: string;
    country: string;
    area1: string;
    area2: string;
    area3: string;
    formatted: string;
    lat: number;
    lng: number;
}
declare class MapToAddressComponent implements OnInit, ControlValueAccessor {
    private readonly coreService;
    mapId: string;
    defaultLngLat: LngLat;
    disabled: boolean;
    language: string;
    currentLngLat?: LngLat;
    private _currentAddress?;
    private _isGoogleLoaded;
    private _loadError?;
    get isGoogleLoaded(): boolean;
    get loadError(): string | undefined;
    set currentAddress(value: string);
    locationChanged: EventEmitter<Location>;
    map: any;
    marker: any;
    location: Location;
    private onChange;
    private onTouched;
    ngOnInit(): Promise<void>;
    initScript(): Promise<void>;
    initMap(): void;
    initializeMap(lngLat: LngLat): void;
    onClick(event: any): void;
    setMapToAddress(): void;
    getAddress(): void;
    parseAddress(results: any): Location;
    getComponentLongName(results: any[], type: string): string;
    getComponentShortName(results: any[], type: string): string;
    writeValue(value: Location): void;
    registerOnChange(fn: (value: Location) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState?(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MapToAddressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<MapToAddressComponent, "haloduck-map-to-address", never, { "disabled": { "alias": "disabled"; "required": false; }; "language": { "alias": "language"; "required": false; }; "currentLngLat": { "alias": "currentLngLat"; "required": false; }; "currentAddress": { "alias": "currentAddress"; "required": false; }; }, { "locationChanged": "locationChanged"; }, never, never, true, never>;
}

declare class SideMenuComponent {
    menuItems: Array<MenuItemEx>;
    depth: number;
    menuItemSelected: EventEmitter<MenuItemEx>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideMenuComponent, "haloduck-side-menu", never, { "menuItems": { "alias": "menuItems"; "required": false; }; "depth": { "alias": "depth"; "required": false; }; }, { "menuItemSelected": "menuItemSelected"; }, never, never, true, never>;
}

declare class SideMenuItemComponent implements OnInit {
    private sanitizer;
    private readonly router;
    menuItem: MenuItemEx;
    depth: number;
    menuItemSelectHandler?: EventEmitter<MenuItemEx>;
    iconSvg: SafeHtml;
    constructor(sanitizer: DomSanitizer);
    ngOnInit(): void;
    onMenuItemSelected(menuItem: MenuItemEx): void;
    navigateTo(link: string[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SideMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SideMenuItemComponent, "haloduck-side-menu-item", never, { "menuItem": { "alias": "menuItem"; "required": false; }; "depth": { "alias": "depth"; "required": false; }; "menuItemSelectHandler": { "alias": "menuItemSelectHandler"; "required": false; }; }, {}, never, never, true, never>;
}

declare class StlViewerComponent implements OnInit, AfterViewInit, OnDestroy {
    fileUrl: string;
    filename: string;
    context: any;
    containerRef: ElementRef;
    private readonly dialogService;
    isPopup: boolean;
    scene: THREE.Scene;
    camera: THREE.PerspectiveCamera;
    renderer: THREE.WebGLRenderer;
    loader: STLLoader;
    controls: OrbitControls;
    loadingPercentage: number;
    showStl(): void;
    download(): void;
    closeDialog(): void;
    animate: () => void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StlViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StlViewerComponent, "haloduck-stl-viewer", never, { "fileUrl": { "alias": "fileUrl"; "required": false; }; "filename": { "alias": "filename"; "required": false; }; "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
}

interface TableColumn {
    key: string | string[];
    label: string;
    width?: string;
    align?: 'text-left' | 'text-center' | 'text-right';
    sortable?: boolean;
    sort?: SearchParams.Sort;
    type?: 'number' | 'date' | 'datetime' | 'time' | 'custom';
    breakpoint?: string;
    hidden?: Observable<boolean>;
    customRenderFn?: (data: any) => Observable<string>;
    customRenderTemplate?: string;
}
interface TableRow extends TableRowProperty {
    [key: string]: any;
}
declare class TableComponent implements OnInit, AfterViewInit {
    private readonly coreService;
    private readonly tableSettingService;
    loadMoreRowRef?: ElementRef;
    tableLayout: 'fixed' | 'auto';
    tableName: string;
    useLoadMore: boolean;
    private defaultAutoLoad;
    private defaultShowHeader;
    columns: TableColumn[];
    rows: Observable<TableRow[]>;
    isLoading: Observable<boolean>;
    isPaging: Observable<boolean>;
    sort: Observable<SearchParams.Sort[]>;
    expandedTemplate?: any;
    customTemplates: {
        [key: string]: any;
    };
    onSortChange: EventEmitter<SearchParams.Sort>;
    lastEvaluatedKey: Observable<any>;
    onLoadMore: EventEmitter<any>;
    onRowClick: EventEmitter<TableRow>;
    onRowDblClick: EventEmitter<TableRow>;
    settings$: Observable<_haloduck_ui.TableSettings>;
    showHeader$: Observable<boolean>;
    autoLoad$: Observable<boolean>;
    getColumnValue(row: TableRow, column: TableColumn): Observable<string>;
    getColumnValueRaw(row: TableRow, column: TableColumn): any;
    getColumnValueRawWithArrayKey(row: TableRow, column: TableColumn): any;
    getNumber(data: any): Observable<string>;
    getDate(data: any): Observable<string>;
    getDateTime(data: any): Observable<string>;
    getTime(data: any): Observable<string>;
    onUpdateSort(field: string | string[], direction: SearchParams.SortDirection): void;
    getSortDirection(field: string | string[]): Observable<string | undefined>;
    onLoadMoreClicked(): void;
    onAutoLoadTriggered(): void;
    onRowClicked(row: TableRow): void;
    onRowDblClicked(row: TableRow): void;
    ngOnInit(): void;
    openSettings(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableComponent, "haloduck-table", never, { "tableLayout": { "alias": "tableLayout"; "required": false; }; "tableName": { "alias": "tableName"; "required": false; }; "useLoadMore": { "alias": "useLoadMore"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "isLoading": { "alias": "isLoading"; "required": false; }; "isPaging": { "alias": "isPaging"; "required": false; }; "sort": { "alias": "sort"; "required": false; }; "expandedTemplate": { "alias": "expandedTemplate"; "required": false; }; "customTemplates": { "alias": "customTemplates"; "required": false; }; "lastEvaluatedKey": { "alias": "lastEvaluatedKey"; "required": false; }; }, { "onSortChange": "onSortChange"; "onLoadMore": "onLoadMore"; "onRowClick": "onRowClick"; "onRowDblClick": "onRowDblClick"; }, never, never, true, never>;
}

interface TableSettings {
    showHeader: boolean;
    autoLoad: boolean;
}
declare class TableSettingService {
    private dialogService;
    private currentOverlayRef?;
    private currentTableNameSubject;
    private settingsSubjects;
    private defaultSettings;
    get currentTableName$(): Observable<string>;
    show(tableName: string): void;
    hide(): void;
    getSettings(tableName: string): Observable<TableSettings>;
    setCurrentTableName(tableName: string): void;
    updateSettings(tableName: string, settings: TableSettings): void;
    private loadSettingsFromStorage;
    private saveSettingsToStorage;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableSettingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TableSettingService>;
}

declare class TableSettingComponent implements OnInit {
    private readonly tableSettingService;
    context?: {
        tableName: string;
        overlayRef: OverlayRef;
    };
    get currentSettings$(): rxjs.Observable<TableSettings>;
    ngOnInit(): void;
    close(): void;
    onSettingChange(settings: TableSettings): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TableSettingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TableSettingComponent, "haloduck-table-setting", never, { "context": { "alias": "context"; "required": false; }; }, {}, never, never, true, never>;
}

declare class ToggleComponent implements ControlValueAccessor, AfterViewInit {
    layout: 'horizontal' | 'vertical';
    value: boolean | null;
    disabled: boolean;
    nullable: boolean;
    toggled: EventEmitter<boolean | null>;
    label: ElementRef;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: any): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState?(isDisabled: boolean): void;
    onToggle(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ToggleComponent, "haloduck-toggle", never, { "layout": { "alias": "layout"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "nullable": { "alias": "nullable"; "required": false; }; }, { "toggled": "toggled"; }, never, ["*"], true, never>;
}

interface TabItem {
    id?: string;
    label: string;
    component: Type<any>;
    inputs?: Record<string, any>;
}
declare class TabsComponent implements OnChanges, AfterViewInit {
    tabs: TabItem[];
    selectedIndex: number;
    layout: 'horizontal' | 'vertical';
    labelWidth: string;
    selectedIndexChange: EventEmitter<number>;
    label: ElementRef;
    ngOnChanges(changes: SimpleChanges): void;
    ngAfterViewInit(): void;
    get current(): TabItem | null;
    select(index: number): void;
    private ensureSelectedInRange;
    static ɵfac: i0.ɵɵFactoryDeclaration<TabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TabsComponent, "haloduck-tabs", never, { "tabs": { "alias": "tabs"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "labelWidth": { "alias": "labelWidth"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; }, never, ["[slot=label]"], true, never>;
}

declare class TagInputComponent implements ControlValueAccessor, AfterViewInit {
    label: ElementRef;
    inputEl: ElementRef<HTMLInputElement>;
    placeholder: string;
    disabled: boolean;
    allowDuplicates: boolean;
    set value(tags: string[] | null);
    valueChange: EventEmitter<string[]>;
    tags: string[];
    inputValue: string;
    onChange: (value: any) => void;
    onTouched: () => void;
    writeValue(value: string[] | null): void;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    ngAfterViewInit(): void;
    focus(): void;
    onInput(event: Event): void;
    onBlur(): void;
    onKeydown(event: KeyboardEvent): void;
    removeTag(index: number): void;
    private commitCurrentInput;
    private addTag;
    private emitChanges;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TagInputComponent, "haloduck-tag-input", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
}

declare class TagViewerComponent implements AfterViewInit {
    label: ElementRef;
    tags: string[];
    shouldWrap: boolean;
    set value(tags: string[] | null);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TagViewerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<TagViewerComponent, "haloduck-tag-viewer", never, { "shouldWrap": { "alias": "shouldWrap"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, ["*"], true, never>;
}

interface GroupedConfig {
    layoutClasses?: string;
    bgClasses?: string;
    borderClasses?: string;
    labelText?: string;
    labelClasses?: string;
    labelOffset?: string;
}
declare class GroupedDirective implements OnInit {
    private elementRef;
    private renderer;
    haloduckGrouped: GroupedConfig | string;
    layoutClasses: string;
    bgClasses: string;
    borderClasses: string;
    labelText: string;
    labelClasses: string;
    labelOffset: string;
    hostClasses: string;
    private labelElement;
    constructor(elementRef: ElementRef, renderer: Renderer2);
    ngOnInit(): void;
    private applyConfig;
    private createLayout;
    private createBorder;
    private createLabel;
    private addClasses;
    private removeBorderClasses;
    updateLabel(text: string): void;
    toggleLabel(show: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<GroupedDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<GroupedDirective, "[haloduckGrouped]", never, { "haloduckGrouped": { "alias": "haloduckGrouped"; "required": false; }; "layoutClasses": { "alias": "layoutClasses"; "required": false; }; "bgClasses": { "alias": "bgClasses"; "required": false; }; "borderClasses": { "alias": "borderClasses"; "required": false; }; "labelText": { "alias": "labelText"; "required": false; }; "labelClasses": { "alias": "labelClasses"; "required": false; }; "labelOffset": { "alias": "labelOffset"; "required": false; }; }, {}, never, never, true, never>;
}

declare class AutoLoadDirective implements OnInit, OnDestroy, OnChanges {
    private readonly elementRef;
    private readonly ngZone;
    private observer?;
    private isLoading;
    autoLoadEnabled: boolean;
    autoLoadThreshold: number;
    autoLoadRootMargin: string;
    autoLoadTrigger: EventEmitter<void>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    private setupObserver;
    private initializeObserver;
    private triggerLoad;
    private temporarilyDisableObserver;
    private disconnect;
    setLoadingState(loading: boolean): void;
    resetAutoLoad(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<AutoLoadDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<AutoLoadDirective, "[haloduckAutoLoad]", never, { "autoLoadEnabled": { "alias": "autoLoadEnabled"; "required": false; }; "autoLoadThreshold": { "alias": "autoLoadThreshold"; "required": false; }; "autoLoadRootMargin": { "alias": "autoLoadRootMargin"; "required": false; }; }, { "autoLoadTrigger": "autoLoadTrigger"; }, never, never, true, never>;
}

declare class BreadcrumbComponent implements OnInit {
    private readonly breadcrumbService;
    listBreadcrumb: {
        label: string;
        url: string;
    }[];
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<BreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<BreadcrumbComponent, "haloduck-breadcrumb", never, {}, {}, never, never, true, never>;
}

declare class DialogService {
    private overlay;
    private injector;
    private dialogStack;
    constructor(overlay: Overlay, injector: Injector);
    open<T>(component: Type<T> | TemplateRef<any>, data?: any, classList?: string[]): OverlayRef;
    close(overlayRef?: OverlayRef): void;
    closeAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DialogService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DialogService>;
}

declare class NotificationComponent {
    private readonly notificationService;
    listNotification$: rxjs.Observable<_haloduck_ui.Notification[]>;
    removeNotification(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NotificationComponent, "haloduck-notification", never, {}, {}, never, never, true, never>;
}

declare global {
    interface Window {
        FlutterApp?: {
            postMessage: (message: string) => void;
        };
    }
}
type NotificationType = 'success' | 'error' | 'warning' | 'info';
interface Notification {
    id: string;
    type: NotificationType;
    message: string;
    timeout?: number;
    timeoutRef?: number;
}
declare class NotificationService {
    private listNotification$;
    private listNotification;
    showNotification(title: string, body: string, timeout?: number, payload?: any): void;
    _showNotification(type: NotificationType, message: string, timeout?: number): string;
    getListNotification(): Observable<Notification[]>;
    removeNotificationById(id: string): void;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationService>;
}

declare class PictureNameComponent {
    name?: string;
    pictureKey?: string;
    cdnUrl?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<PictureNameComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<PictureNameComponent, "haloduck-picture-name", never, { "name": { "alias": "name"; "required": false; }; "pictureKey": { "alias": "pictureKey"; "required": false; }; "cdnUrl": { "alias": "cdnUrl"; "required": false; }; }, {}, never, never, true, never>;
}

declare const provideHaloduckTransloco: () => {
    provide: i0.InjectionToken<_jsverse_transloco.TranslocoScope>;
    useValue: _jsverse_transloco.TranslocoScope;
    multi: boolean;
}[];

export { AuthenticateComponent, AutoLoadDirective, BreadcrumbComponent, ButtonComponent, CalendarComponent, ConfirmDialogService, CopyButtonComponent, DatePickerComponent, DateRangeComponent, DialogService, DrawCanvasComponent, ERROR_NOT_ACCEPTABLE_FILE_TYPE, ERROR_OVER_COUNT, ERROR_OVER_SIZE, ERROR_UPLOAD, FileUploaderComponent, FlipComponent, GroupedDirective, ImageUploaderComponent, ImageViewerComponent, InputComponent, LanguageSelectorComponent, MapToAddressComponent, NotificationComponent, NotificationService, PictureNameComponent, SelectComponent, SelectDropdownComponent, SideMenuComponent, SideMenuItemComponent, StlViewerComponent, TableComponent, TableSettingComponent, TableSettingService, TabsComponent, TagInputComponent, TagViewerComponent, ToggleComponent, dateToString, google, provideHaloduckTransloco };
export type { ButtonVariant, CalendarDate, DateRange, DateRangeDropdown, FileEx, GroupedConfig, Location, Notification, NotificationType, Option, TabItem, TableColumn, TableRow, TableSettings };