import * as i0 from '@angular/core';
import { ElementRef, TemplateRef, ViewContainerRef, NgZone, EventEmitter, OnInit, OnChanges, OnDestroy, SimpleChanges, DoCheck, AfterViewInit, ChangeDetectorRef, InjectionToken } from '@angular/core';
import * as i60 from '@angular/cdk/overlay';
import { ConnectedPosition, OverlayRef, Overlay } from '@angular/cdk/overlay';
import { Observable, BehaviorSubject } from 'rxjs';
import * as i62 from '@ngx-translate/core';
import { TranslateService } from '@ngx-translate/core';
import * as i58 from '@angular/cdk/drag-drop';
import { CdkDragDrop } from '@angular/cdk/drag-drop';
import { fabric } from 'fabric';
import { Transform } from 'fabric/fabric-impl';
import { HttpClient } from '@angular/common/http';
import * as i57 from '@angular/forms';
import { ControlValueAccessor } from '@angular/forms';
import { ChartData, ChartConfiguration } from 'chart.js';
import * as i61 from 'ng2-charts';
import { BaseChartDirective } from 'ng2-charts';
import * as i56 from '@angular/common';
import * as i59 from '@almothafar/angular-signature-pad';

declare class ZenNotifyService {
    private readonly _overlay;
    private readonly _injector;
    /** The currently shown snackbar overlay, if any. */
    private _overlayRef;
    /** Auto-dismiss timer handle for the current snackbar. */
    private _timer;
    info(msg: string, duration?: number, hasDismiss?: boolean): void;
    neutral(msg: string, duration?: number, hasDismiss?: boolean): void;
    success(msg: string, duration?: number, hasDismiss?: boolean): void;
    warn(msg: string, duration?: number, hasDismiss?: boolean): void;
    error(err: unknown, duration?: number, hasDismiss?: boolean): void;
    /**
     * Renders the snackbar through a CDK overlay so it shares the browser top
     * layer with CDK dialogs and always paints above them. Only one snackbar is
     * shown at a time — a new call replaces the previous one.
     */
    private _show;
    /** Disposes the active snackbar overlay and clears the auto-dismiss timer. */
    private _dismiss;
    private getErrorMessage;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenNotifyService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZenNotifyService>;
}

/** Why a connected panel asked to close. */
type ZenPanelCloseReason = 'outside' | 'escape' | 'detach';
/**
 * Configuration for opening a viewport-aware connected panel via
 * {@link ZenduOverlayService}. This is the shared dropdown/menu primitive used
 * across the library (select, date-picker, filter menus, …) so every floating
 * panel positions, flips, and clamps the same way — and escapes overflow /
 * transformed ancestors instead of being clipped by them.
 */
interface ZenConnectedPanelConfig {
    /** Element the panel is anchored to (the trigger). */
    origin: ElementRef<HTMLElement> | HTMLElement;
    /** Template rendered inside the overlay. */
    content: TemplateRef<unknown>;
    /**
     * The host component's `ViewContainerRef`. Required so the embedded view
     * keeps the component's dependency-injection and style-encapsulation
     * context even though it is physically rendered in the overlay container.
     */
    viewContainerRef: ViewContainerRef;
    /**
     * Panel width:
     * - `'origin'` (default) — match the trigger's width (typical for selects),
     * - `'auto'` — size to the content (typical for the date-picker),
     * - a number (px) or any CSS width string.
     */
    width?: 'origin' | 'auto' | number | string;
    /** Minimum width (px or CSS string). */
    minWidth?: number | string;
    /**
     * Minimum height (px or CSS string). Also opts a tall panel into CDK's
     * flexible (clamp + internal scroll) path instead of being pushed off-screen.
     */
    minHeight?: number | string;
    /** Gap between the trigger and the panel, in px. Default 4. */
    offsetY?: number;
    /**
     * Explicit connected positions in preference order, overriding the default
     * below→above / start→end fallback. The first that fits wins; `withPush` and
     * flexible dimensions still clamp the panel into the viewport regardless of
     * order. Consumers that honour a directional input (e.g. the filter's
     * `position`) supply this to steer the *preferred* side; omit it to keep the
     * default behaviour (what `zen-select` uses).
     */
    positions?: ConnectedPosition[];
    /** Extra class(es) applied to the overlay pane. */
    panelClass?: string | string[];
    /**
     * Behaviour when an ancestor scrolls:
     * - `'reposition'` (default) — keep the panel glued to the trigger,
     * - `'close'` — detach the panel (emits a `'detach'` close reason),
     * - `'block'` — freeze the trigger's scroll container while the panel is
     *   open (an app-shell-friendly stand-in for Material's mat-select block;
     *   CDK's BlockScrollStrategy only locks the document root).
     */
    scrollBehavior?: 'reposition' | 'close' | 'block';
    /** Margin kept clear of the viewport edges, in px. Default 8. */
    viewportMargin?: number;
}
/** Handle to an open connected panel. */
interface ZenConnectedPanelRef {
    /** Underlying CDK overlay ref (escape hatch for advanced needs). */
    readonly overlayRef: OverlayRef;
    /**
     * Emits when the panel should close: an outside click, the Escape key, or
     * the overlay detaching (e.g. `scrollBehavior: 'close'`). The consumer owns
     * its own open state, so it decides what to do with this.
     */
    readonly closed: Observable<ZenPanelCloseReason>;
    /** Recompute the panel position (e.g. after its content resizes). */
    updatePosition(): void;
    /** Detach and dispose the panel. */
    close(): void;
}

/**
 * Shared overlay primitive for the whole library. Opens a floating panel
 * anchored to a trigger using CDK Overlay, with viewport-aware connected
 * positioning that:
 *  - renders in the overlay container, so it is never clipped by an ancestor's
 *    `overflow` (cards, scroll areas) or by the viewport edge;
 *  - prefers opening below the trigger and flips above when there isn't room;
 *  - pushes itself into the viewport and shrinks to fit (`flexibleDimensions`),
 *    so the panel scrolls internally instead of overflowing;
 *  - tracks the trigger on scroll/resize (or closes, if asked).
 *
 * Consumers keep their own open/close state and panel markup — they call
 * {@link openConnectedPanel} and react to {@link ZenConnectedPanelRef.closed}.
 */
declare class ZenduOverlayService {
    private _overlay;
    private _ngZone;
    constructor(_overlay: Overlay, _ngZone: NgZone);
    openConnectedPanel(config: ZenConnectedPanelConfig): ZenConnectedPanelRef;
    /**
     * Fallback order: below the trigger (start- then end-aligned), then above
     * (start- then end-aligned). CDK picks the first that fits; `withPush`
     * nudges it fully on-screen.
     */
    private _positions;
    /**
     * Lock the trigger's nearest scrollable ancestor (or the document) with
     * `overflow: hidden` so the page can't scroll while the panel is open, and
     * pad for the now-missing scrollbar so content doesn't jump. Returns an
     * idempotent restore fn that puts the inline styles back.
     */
    private _lockScrollContainer;
    /**
     * Walk up from the trigger to the first ancestor that actually scrolls
     * (overflow-y auto/scroll AND content taller than the box). Falls back to
     * the document scrolling element so block always has something to lock.
     */
    private _findScrollContainer;
    private _panelClasses;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduOverlayService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZenduOverlayService>;
}

declare class ZenduCheckboxComponent {
    checked: boolean;
    checkedChange: EventEmitter<boolean>;
    label: string | number;
    labelColor: string;
    disabled: boolean;
    disableValueChange: boolean;
    indeterminate: boolean;
    imageUrl: string;
    size: 'sm' | 'md';
    supportingText: string;
    /**
     * Toggle state
     */
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduCheckboxComponent, "zen-checkbox", never, { "checked": { "alias": "checked"; "required": false; }; "label": { "alias": "label"; "required": false; }; "labelColor": { "alias": "labelColor"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "disableValueChange": { "alias": "disableValueChange"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "size": { "alias": "size"; "required": false; }; "supportingText": { "alias": "supportingText"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, false, never>;
}

declare class ZenduToggleComponent {
    enabled: boolean;
    enabledChange: EventEmitter<boolean>;
    size: 'sm' | 'md';
    disabled: boolean;
    label: string;
    supportingText: string;
    /**
     * Toggle state
     */
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduToggleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduToggleComponent, "zen-toggle", never, { "enabled": { "alias": "enabled"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "label": { "alias": "label"; "required": false; }; "supportingText": { "alias": "supportingText"; "required": false; }; }, { "enabledChange": "enabledChange"; }, never, never, false, never>;
}

declare class ZenduToggleSlideComponent {
    enabled: boolean;
    enabledChange: EventEmitter<boolean>;
    disabled: boolean;
    /**
     * Toggle state
     */
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduToggleSlideComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduToggleSlideComponent, "zen-toggle-slide", never, { "enabled": { "alias": "enabled"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "enabledChange": "enabledChange"; }, never, never, false, never>;
}

declare class ZenduSearchBoxComponent implements OnInit {
    private _element;
    private _ngZone;
    text: string;
    textChange: EventEmitter<string>;
    set delay(val: number);
    autoFocus: boolean;
    disabled: boolean;
    placeholder: string;
    private _debouncedInvoke;
    private _focusAttempts;
    constructor(_element: ElementRef, _ngZone: NgZone);
    ngOnInit(): void;
    onChange(): void;
    clearFromParent(): void;
    clear(): void;
    private invokeChange;
    private setDelay;
    doFocus(): void;
    private getInput;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSearchBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduSearchBoxComponent, "zen-search-box", never, { "text": { "alias": "text"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "textChange": "textChange"; }, never, never, false, never>;
}

declare class ZenduSelectOptionDirective {
    template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSelectOptionDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ZenduSelectOptionDirective, "[zen-select-option]", never, {}, {}, never, never, false, never>;
}

declare class ZenduSelectValueDirective {
    template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSelectValueDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ZenduSelectValueDirective, "[zen-select-value]", never, {}, {}, never, never, false, never>;
}

declare class ZenduSelectButtonDirective {
    template: TemplateRef<any>;
    constructor(template: TemplateRef<any>);
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSelectButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ZenduSelectButtonDirective, "[zen-select-custom-button]", never, {}, {}, never, never, false, never>;
}

declare enum DATEPICKER_POSITION {
    AUTO = "auto",
    LEFT = "left",
    RIGHT = "right",
    TOP = "top",
    BOTTOM = "bottom"
}

interface DateRange {
    start: Date;
    end: Date;
}

interface NumberRange {
    from?: number;
    to?: number;
}

interface FiltersConfig {
    items: FiltersConfigItem[];
}
interface FiltersConfigItem {
    /**
     * Section title
     */
    title: string;
    /**
     * Key for result store
     */
    key: string;
    /**
     * Data type
     */
    type: "multiselect" | "select" | "dateRange" | "numberRange" | "toggle" | "date" | "radio" | "divider" | "text" | "duration" | "distance";
    /**
     * Show time for date pickers. By default is true
     */
    showTime?: boolean;
    /**
     * Data source for type Multiselect
     */
    dataSource?: DataSource[];
    filteredDataSource?: DataSource[];
    /**
     * Date range for type DateRange
     */
    dateRange?: DateRange;
    /**
     * Date result for type Date
     */
    date?: Date;
    /**
     * Number range for type NumberRange
     */
    numberRange?: NumberRange;
    /**
     * Option for Radio
     * Selected added here for reset Filter.
     */
    radioOptions?: Array<{
        id: string;
        name: string;
        selected?: boolean;
        disabled?: boolean;
        imageUrl?: string;
    }>;
    /**
     * Selected Radio button result
     */
    selectedRadio?: string;
    /**
     * Enable/Disabled state for the type Toggle
     */
    enabled?: boolean;
    /**
     * Menu is expanded
     */
    expanded?: boolean;
    /**
     * Is selected all
     */
    isSelectedAll?: boolean;
    /**
     * Hide "Select All" option for multiselect. By default is false
     */
    hideSelectAll?: boolean;
    /**
     * Disable menu collapse
     */
    disableCollapse?: boolean;
    /**
     * Configs
     */
    config?: {
        yPosition?: DATEPICKER_POSITION;
    };
    /**
     * Show predefined date-range options. By default is false
     */
    showDateRangeOptions?: boolean;
    /**
     * List of custom date-range options to replace default options
     */
    dateRangeOptions?: {
        name: string;
        dateRange: DateRange;
    }[];
    /**
     * Is lazy loading mode activated for data sources
     */
    isLazyLoading?: boolean;
    /**
     * lazy loading handler
     */
    lazyLoader?: (search: {
        text?: string;
        ids?: string[];
    }, offset: number, limit: number) => Promise<DataSource[]>;
    /**
     * is data is loading now
     */
    isLoadingNow?: boolean;
    /**
     * If true, the button 'Load more' will be displayed
     */
    canLoadMore?: boolean;
}
interface DataSource {
    id: string | number;
    name: string | number;
    checked?: boolean;
    imageUrl?: string;
    isOpen?: boolean;
    children?: string[];
    parentId?: string | number;
    level?: number;
    index?: number;
    badgeBgColor?: string;
    badgeColor?: string;
}
interface MultiSelectItem {
    id: string | number;
    name: string | number;
    index: number;
}

interface LazyLoaderSearch {
    text?: string;
    ids?: string[];
}
interface LazyLoaderResult {
    id: string | number;
    name?: string | number;
    text?: string;
    checked?: boolean;
    imageUrl?: string;
    isOpen?: boolean;
    children?: string[];
    parentId?: string | number;
    level?: number;
    index?: number;
    badgeBgColor?: string;
    badgeColor?: string;
}
type LazyLoaderFunction = (search: LazyLoaderSearch, offset: number, limit: number) => Promise<LazyLoaderResult[]>;
interface AddOptionEvent {
    value: string;
}
interface RemoveOptionEvent {
    removed: boolean;
}
interface SelectOption {
    [key: string]: any;
    id?: string | number;
    name?: string;
    icon?: string;
    iconName?: string;
    avatar?: string;
    dotColor?: string;
    secondaryText?: string;
}
declare class ZenduSelectComponent implements OnChanges, OnDestroy {
    private elementRef;
    private overlay;
    private viewContainerRef;
    /**
     * 2-Way component property for selected items.
     * Don't initialize property on constructor to prevent change source parameter
     */
    selectModel: any | any[];
    /**
     * callback to emit changes for parent component
     */
    selectModelChange: EventEmitter<any>;
    /**
     * List of options
     */
    options: SelectOption[] | any[];
    /**
     * Label text above the select
     */
    label?: string;
    /**
     * Show a help icon next to the label. On hover/keyboard-focus it reveals a
     * self-contained tooltip with `helpTooltip` (the library does not depend on
     * Angular Material).
     */
    helpIcon: boolean;
    /**
     * Tooltip text shown on hover/focus of the label help icon. Translated.
     */
    helpTooltip: string;
    /**
     * Supporting text below the select
     */
    supportingText?: string;
    /**
     * Hint text (shown below select)
     */
    hintText: string;
    /**
     * Placeholder text
     */
    placeholder: string;
    /**
     * Leading element type
     */
    leadingType: 'default' | 'icon' | 'avatar' | 'dot' | 'search';
    /**
     * Icon for icon leading type
     */
    leadingIcon?: string;
    /**
     * Avatar URL for avatar leading type
     */
    leadingAvatar?: string;
    /**
     * Dot color for dot leading type
     */
    leadingDotColor?: string;
    /**
     * This is a key value to get display name from option object
     */
    displayProp: string;
    /**
     * This is a key value to get id from option object
     */
    idProp: string;
    /**
     * Enable search functionality
     */
    hasSearch: boolean;
    /**
     * Component property to enable multiselect
     */
    isMultiselect: boolean;
    /**
     * Alias for isMultiselect for easier usage
     */
    set multiselect(value: boolean);
    get multiselect(): boolean;
    /**
     * Auto-detected tree mode: true if any option has a `children` array
     */
    isTreeMode: boolean;
    /**
     * Hide "Select All" option in both tree mode and flat multiselect
     */
    hideSelectAll: boolean;
    /**
     * Hide search box in tree mode
     */
    hideTreeSearch: boolean;
    /**
     * Mark the select as required (shows * indicator on label)
     */
    required: boolean;
    /**
     * Disable the select
     */
    disabled: boolean;
    /**
     * Show error state
     */
    error: boolean;
    /**
     * Error message to display
     */
    errorMessage?: string;
    /**
     * Destructive/error state (similar to zen-input)
     */
    destructive: boolean;
    /**
     * Size variant
     */
    size: 'sm' | 'md';
    /**
     * Component property to return whole option object
     * By default only id value is returned
     */
    returnOption: boolean;
    /**
     * Truncate text with "..." at the end
     */
    isTruncate: boolean;
    /**
     * show Add New Option at first place
     */
    enableAddNewOption: boolean;
    /**
     * Show Add New option text by default if newOptionText empty
     */
    showDefaultAddOption: boolean;
    /**
     * display custom text for Add New Option
     */
    newOptionText: string;
    /**
     * Emit event when Add New Option is clicked
     */
    addNewOption: EventEmitter<AddOptionEvent>;
    /**
     * show remove Option at first place
     */
    enableRemoveOption: boolean;
    /**
     * display custom text for remove Option
     */
    removeOptionText: string;
    /**
     * Enable lazy loading for options
     */
    isLazyLoading: boolean;
    /**
     * Lazy loader function to fetch options
     */
    lazyLoader?: LazyLoaderFunction;
    /**
     * Preferred direction for dropdown to open
     */
    preferredOpenDirection: 'auto' | 'up' | 'down';
    /**
     * Extra class(es) applied to the dropdown's overlay panel (rendered at body
     * level). Use this to style the detached panel — it is no longer a
     * descendant of the select host, so a consuming component's `::ng-deep`
     * rules scoped under the host can't reach it. Omit for default styling.
     */
    panelClass?: string | string[];
    /**
     * Minimum width (px) for the dropdown panel. The panel still matches the
     * trigger width (`width: 'origin'`) by default; this is only a floor, so it
     * can only ever widen the panel — useful when the trigger is a narrow custom
     * button. Omit to keep the panel exactly trigger-width (unchanged behaviour).
     */
    panelMinWidth?: number;
    /**
     * Emit event when remove Option is clicked
     */
    removeOption: EventEmitter<RemoveOptionEvent>;
    /**
     * Emit event when select is closed, sending the selected data
     */
    closed: EventEmitter<any | any[]>;
    /**
     * State tracking. `isOpen` is the single source of truth — assigning it
     * attaches/detaches the CDK overlay panel, so every existing open/close path
     * (toggle, search focus/typing, option select, hideDropDown) stays correct
     * without touching each call site.
     */
    private _isOpen;
    get isOpen(): boolean;
    set isOpen(open: boolean);
    helpTooltipAlign: 'center' | 'start' | 'end';
    helpTooltipPlacement: 'above' | 'below';
    searchText: string;
    searchInputValue: string;
    searchFocused: boolean;
    filteredOptions: SelectOption[] | any[];
    selectedDisplay: string;
    labelText: string;
    option: SelectOption | null;
    canLoadMore: boolean;
    isLoadingNow: boolean;
    private _searchDebounce;
    private _singlePick;
    private _pickFetching;
    treeFilteredDataSource: DataSource[];
    isSelectedAll: boolean;
    /**
     * Select Option Template for custom HTML
     */
    optionTemplate: ZenduSelectOptionDirective;
    /**
     * Select Value Template for custom HTML
     */
    valueTemplate: ZenduSelectValueDirective;
    /**
     * Select Button Template for custom HTML
     */
    buttonTemplate: ZenduSelectButtonDirective;
    /** Trigger element the overlay panel is anchored to. */
    private selectWrapper?;
    /** The dropdown panel content, rendered into the overlay when open. */
    private dropdownPanel?;
    private _panelRef;
    constructor(elementRef: ElementRef, overlay: ZenduOverlayService, viewContainerRef: ViewContainerRef);
    ngOnDestroy(): void;
    /**
     * Open the dropdown panel in a CDK overlay anchored to the trigger. The
     * overlay handles viewport-aware positioning (flip up/down, push into view,
     * clamp + internal scroll) and renders at the body level, so the panel is
     * never clipped by an ancestor's `overflow` or by the viewport edge.
     */
    private _openOverlay;
    private _closeOverlay;
    /**
     * Resolve icon path with fallback to assets folder
     */
    private resolveIconPath;
    /**
     * Get icon for display (with fallback logic)
     */
    getIconPath(option?: SelectOption, leadingIcon?: string): string | null;
    ngOnChanges(changeObj: {
        [key: string]: {
            currentValue: unknown;
            previousValue: unknown;
            firstChange: boolean;
        };
    }): void;
    /**
     * Toggle dropdown
     */
    /**
     * Position the help tooltip so it never overflows the viewport. Horizontally:
     * anchored to the icon's right edge near the right border, to its left edge near
     * the left border, otherwise centered. Vertically: above by default, flipped
     * below when there isn't room above and there's more room below (the label-row
     * icon sits high in the layout). Computed from the icon rect synchronously
     * (before paint) so the tooltip appears in its final spot without a flicker.
     */
    updateHelpTooltipPlacement(event: Event): void;
    toggleDropdown(): void;
    /**
     * Handle scroll on the options list — fetch the next page once the user
     * scrolls near the bottom (lazy loading only).
     */
    onOptionsScroll(event: Event): void;
    /**
     * Reset and re-fetch the first page when the search text changes in lazy
     * mode (debounced so we don't fire a request on every keystroke).
     */
    private reloadLazySearch;
    /**
     * Handle option selection
     */
    selectOption(option: SelectOption): void;
    /**
     * Toggle option in multiselect mode
     */
    private toggleMultiselectOption;
    /**
     * Check if option is selected
     */
    isSelected(option: SelectOption): boolean;
    /**
     * Get display text for option
     */
    getOptionDisplay(option: any): string;
    /**
     * Alias for getOptionDisplay for backward compatibility
     */
    getName(option: string | object): string;
    /**
     * Get value for option (using idProp)
     */
    getOptionValue(option: SelectOption): string | number;
    /**
     * Get id value from option
     */
    private getId;
    /**
     * Update displayed text
     */
    private updateDisplay;
    /**
     * The option of a multiselect value: from the static options or, for a lazy
     * select, the pages it has loaded (BT-11533).
     */
    private multiselectOption;
    /**
     * The name of a multiselect's one picked value, remembered so a search that
     * replaces the loaded pages does not turn it back into the placeholder.
     */
    private singlePickName;
    /**
     * Fetches a lazy multiselect's one picked value by id when the loaded pages
     * do not hold it, for its name only: the list itself is left as it is.
     */
    private loadPickedName;
    /**
     * Find option by value
     */
    private findOptionByValue;
    /**
     * Check if model is empty
     */
    isModelEmpty(): boolean;
    /**
     * Get element index in multiselect array
     */
    private getElementIndex;
    /**
     * Toggle all options in multiselect
     */
    toggleAll(): void;
    /**
     * Toggle Select All option for flat multiselect
     */
    toggleSelectAll(): void;
    /**
     * Check if all filtered options are selected
     */
    isAllSelected(): boolean;
    /**
     * Get recursive property from nested object
     */
    private getRecursiveProperty;
    /**
     * Update label text
     */
    updateLabel(): void;
    /**
     * Get name from value
     */
    getNameFromValue(val: any): string;
    /**
     * Emit change event
     */
    private emitChange;
    /**
     * Filter options based on search
     */
    filterOptions(): void;
    /**
     * Handle search input
     */
    onSearchChange(): void;
    clearSearch(): void;
    /**
     * Handle search input change for search type
     */
    onSearchInputChange(): void;
    /**
     * Handle search input focus
     */
    onSearchFocus(): void;
    /**
     * Handle search input blur
     */
    onSearchBlur(event: FocusEvent): void;
    /**
     * Get selected option for leading display
     */
    getSelectedOption(): SelectOption | null;
    /**
     * Get selected secondary text for display
     */
    getSelectedSecondaryText(): string | null;
    /**
     * Hide dropdown
     */
    hideDropDown(userAction?: boolean): Promise<void>;
    /**
     * Handle Enter key on search input
     */
    onSearchEnter(event: Event): void;
    /**
     * Handle add new option
     */
    handleAddNewOption(): void;
    /**
     * Handle remove option
     */
    handleRemoveOption(): void;
    /**
     * Get state classes
     */
    getStateClasses(): string;
    /**
     * Load more items for lazy loading
     */
    loadMore(showSelectedOnTop: boolean): Promise<void>;
    /**
     * Initialize tree data by syncing selectModel IDs to DataSource checked flags
     */
    private initTreeData;
    /**
     * Handle checked change from zen-groups in tree mode
     */
    onTreeCheckedChange(dsItem: DataSource): void;
    /**
     * Handle select all change from zen-groups in tree mode
     */
    onTreeSelectAllChange(isSelectedAll: boolean): void;
    /**
     * Update the isSelectedAll flag based on current checked state
     */
    private updateTreeSelectAllState;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSelectComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduSelectComponent, "zen-select", never, { "selectModel": { "alias": "selectModel"; "required": false; }; "options": { "alias": "options"; "required": false; }; "label": { "alias": "label"; "required": false; }; "helpIcon": { "alias": "helpIcon"; "required": false; }; "helpTooltip": { "alias": "helpTooltip"; "required": false; }; "supportingText": { "alias": "supportingText"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "leadingType": { "alias": "leadingType"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "leadingAvatar": { "alias": "leadingAvatar"; "required": false; }; "leadingDotColor": { "alias": "leadingDotColor"; "required": false; }; "displayProp": { "alias": "displayProp"; "required": false; }; "idProp": { "alias": "idProp"; "required": false; }; "hasSearch": { "alias": "hasSearch"; "required": false; }; "isMultiselect": { "alias": "isMultiselect"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "hideSelectAll": { "alias": "hideSelectAll"; "required": false; }; "hideTreeSearch": { "alias": "hideTreeSearch"; "required": false; }; "required": { "alias": "required"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "error": { "alias": "error"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "destructive": { "alias": "destructive"; "required": false; }; "size": { "alias": "size"; "required": false; }; "returnOption": { "alias": "returnOption"; "required": false; }; "isTruncate": { "alias": "isTruncate"; "required": false; }; "enableAddNewOption": { "alias": "enableAddNewOption"; "required": false; }; "showDefaultAddOption": { "alias": "showDefaultAddOption"; "required": false; }; "newOptionText": { "alias": "newOptionText"; "required": false; }; "enableRemoveOption": { "alias": "enableRemoveOption"; "required": false; }; "removeOptionText": { "alias": "removeOptionText"; "required": false; }; "isLazyLoading": { "alias": "isLazyLoading"; "required": false; }; "lazyLoader": { "alias": "lazyLoader"; "required": false; }; "preferredOpenDirection": { "alias": "preferredOpenDirection"; "required": false; }; "panelClass": { "alias": "panelClass"; "required": false; }; "panelMinWidth": { "alias": "panelMinWidth"; "required": false; }; }, { "selectModelChange": "selectModelChange"; "addNewOption": "addNewOption"; "removeOption": "removeOption"; "closed": "closed"; }, ["optionTemplate", "valueTemplate", "buttonTemplate"], never, false, never>;
}

interface DatePickerDay {
    date: Date;
    lbl: string;
    selected: boolean;
    isOutside: boolean;
    isDisabled: boolean;
    isHighlighted: boolean;
    markerColors?: (string | undefined)[];
}

interface DatePickerHint {
    description: string;
    maskText: string;
    date: Date;
}

declare class ZenduDatepickerComponent implements OnChanges {
    private _element;
    private overlay;
    private viewContainerRef;
    private _translate;
    /**
     * Component property
     */
    date: Date;
    /**
     * callback to emit changes for parent component
     */
    dateChange: EventEmitter<Date>;
    showTime: boolean;
    showSeconds: boolean;
    showDate: boolean;
    parentContainer: HTMLElement | null;
    containerClass: string;
    minDate: Date;
    maxDate: Date;
    boxDesign: boolean;
    highlightDays: number[];
    autoConfirm: boolean;
    hint: DatePickerHint;
    /**
     * datepicker states
     */
    highlightError: boolean;
    disabled: boolean;
    readonly: boolean;
    xPosition: DATEPICKER_POSITION;
    yPosition: DATEPICKER_POSITION;
    dispalyOverParent: boolean;
    dateMenu: ElementRef;
    triggerButton: ElementRef;
    dateMenuTemplate: TemplateRef<unknown>;
    private overlayRef;
    selectedTime: {
        Hr: number;
        Min: number;
        Sec: number;
    };
    isPickerVisible: boolean;
    dayRows: Array<{
        days: DatePickerDay[];
    }>;
    daysTitle: string;
    weekDays: string[];
    currentSlot: Date;
    hour: string;
    min: string;
    sec: string;
    isPM: boolean;
    _dateToSet: Date;
    months: string[];
    years: any[];
    monthPickerVisible: boolean;
    yearPickerVisible: boolean;
    right: boolean;
    bottom: boolean;
    constructor(_element: ElementRef, overlay: Overlay, viewContainerRef: ViewContainerRef, _translate: TranslateService);
    outsideHandling(event: any): void;
    scroll(): void;
    ngOnChanges(changes: SimpleChanges): void;
    updatePlacement(): void;
    private getVerticalMenuDirection;
    /**
     * Used to get datepicker position
     * @returns either "left" or "right"
     */
    private getHorizontalMenuDirection;
    togglePicker(): void;
    private createOverlay;
    closePicker(): void;
    ngOnDestroy(): void;
    private showDatePicker;
    private syncMenuPositionWithDelay;
    private calculateTopPosition;
    private updateDays;
    nextMonth(): void;
    prevMonth(): void;
    nextYear(): void;
    prevYear(): void;
    nextYearGroup(): void;
    prevYearGroup(): void;
    selectDay(day: DatePickerDay): void;
    selectMonth(month: number): void;
    selectYear(year: number): void;
    hideTimePicker(): void;
    timeChanged(): void;
    formattedDate(): string;
    formattedTime(): string;
    toggleTime(): void;
    showMonthPicker(): void;
    showYearPicker(): void;
    hourUp(): void;
    hourDown(): void;
    minUp(): void;
    minDown(): void;
    secUp(): void;
    secDown(): void;
    apply(): void;
    cancel(): void;
    clear(): void;
    getIcon(): "assets/ng-zenduit/icons/date.svg" | "assets/ng-zenduit/icons/calendar.svg" | "assets/ng-zenduit/icons/time.svg";
    selectHintDate(date: Date): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduDatepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduDatepickerComponent, "zen-datepicker", never, { "date": { "alias": "date"; "required": false; }; "showTime": { "alias": "showTime"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "showDate": { "alias": "showDate"; "required": false; }; "parentContainer": { "alias": "parentContainer"; "required": false; }; "containerClass": { "alias": "containerClass"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "boxDesign": { "alias": "boxDesign"; "required": false; }; "highlightDays": { "alias": "highlightDays"; "required": false; }; "autoConfirm": { "alias": "autoConfirm"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "highlightError": { "alias": "highlightError"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "xPosition": { "alias": "xPosition"; "required": false; }; "yPosition": { "alias": "yPosition"; "required": false; }; "dispalyOverParent": { "alias": "dispalyOverParent"; "required": false; }; }, { "dateChange": "dateChange"; }, never, never, false, never>;
}

declare class ZenduFilterComponent implements OnChanges, DoCheck, AfterViewInit, OnDestroy {
    private overlay;
    private viewContainerRef;
    config: FiltersConfig;
    filter: object;
    position: string;
    resetBehavior: 'set_all' | 'clear';
    defaultFilter?: object;
    filterChange: EventEmitter<object>;
    /**
     * Open/closed state and the single source of truth for the panel. Assigning it
     * attaches/detaches the CDK overlay panel, so every existing open/close path
     * (toggle, hide, apply, external `[(isVisible)]` binding) stays correct without
     * touching each call site — mirrors zen-select's `isOpen`.
     */
    private _isVisible;
    set isVisible(open: boolean);
    get isVisible(): boolean;
    isVisibleChange: EventEmitter<boolean>;
    customTrigger: boolean;
    imageUrl: string;
    label: string;
    triggerVariant: 'default' | 'icon-only';
    showOptions: boolean;
    customOptions: string;
    wrapperBodyClass: string;
    /**
     * @deprecated Obsolete since the panel moved to the CDK overlay
     * (ZenduOverlayService), which owns positioning. Kept for back-compat so
     * existing `[customPosition]` bindings keep compiling; it no longer has any
     * effect. Use `position` to steer the preferred side.
     */
    customPosition: 'fixed' | 'absolute';
    searchText: string;
    isApplied: boolean;
    private lastAppliedFilter;
    private resetedFilter;
    private _defaultFilterSignature;
    selectedCount: number;
    resetDisabled: boolean;
    appliedCount: number;
    hasActiveFilters: boolean;
    showNoFilterResult: boolean;
    errorMessage: string[];
    private _errorMessageTimer?;
    selectedDateRangeOptions: {
        [key: string]: string;
    };
    /** Trigger element the overlay panel is anchored to. */
    _componentElement: ElementRef<HTMLElement>;
    /** The filter panel content, rendered into the overlay when open. */
    private filterPanel?;
    private _panelRef;
    constructor(overlay: ZenduOverlayService, viewContainerRef: ViewContainerRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Open the filter panel in a CDK overlay anchored to the trigger. The overlay
     * owns viewport-aware positioning (flip up/down, push into view, clamp +
     * internal scroll) and renders at the body level, so the panel is never
     * clipped by an ancestor's `overflow` or by the viewport edge. Mirrors
     * zen-select's `_openOverlay`.
     */
    private _openOverlay;
    private _closeOverlay;
    /**
     * Map the `position` input ('left' | 'right' | 'top' | 'bottom' | 'auto', or
     * combinations) to CDK connected positions in preference order. The requested
     * side comes first; the remaining three are fallbacks so the panel always
     * fits. 'left' aligns the panel's right edge to the trigger (opens leftward),
     * 'right' aligns its left edge (opens rightward); 'auto' picks the side with
     * more room. `withPush` + flexible dimensions still clamp into the viewport.
     */
    private _buildConnectedPositions;
    ngOnChanges(changes: any): void;
    ngDoCheck(): void;
    /**
     * Focus the panel's search box when it opens. The panel renders in the overlay
     * at body level, so it isn't reachable via `@ViewChild`; zen-search-box also
     * self-focuses on init (`autoFocus`), and we nudge the rendered input directly
     * as a fallback once the overlay has attached.
     */
    focusSearchBox(): void;
    isMenuIsVisible(item: FiltersConfigItem): boolean;
    private extractUniqueDataSource;
    onSelectAll(item: FiltersConfigItem): void;
    isItemActive(item: FiltersConfigItem): boolean;
    /**
     * Whether a section is actively contributing to the filter — used to show the
     * per-section "applied" dot next to its chevron. Mirrors the per-type gating
     * of computeSelectedCount() (e.g. a radio only counts when it differs from the
     * default), so the dot and the trigger count badge can never disagree. Unlike
     * isItemActive(), this has no side effects and treats a default radio as
     * inactive.
     */
    isItemFiltered(item: FiltersConfigItem): boolean;
    searchTextChanged(): void;
    private resetLazyLoadingSources;
    private filterItems;
    loadMore(item: FiltersConfigItem, showSelectedOnTop: boolean): Promise<void>;
    toggleItem(item: FiltersConfigItem): void;
    toggleEnabled(item: FiltersConfigItem): void;
    private resetFilters;
    private restorePreviousApplied;
    /**
     * Reflects a filter object onto the in-panel item state (checkboxes, radios,
     * ranges, toggle/date) without emitting. Used to restore the last-applied
     * filter and to reset the panel to a provided `defaultFilter`.
     */
    private applyFilterToItems;
    reset(): void;
    /**
     * Resets the dropdown's internal selection state (checkboxes, radios, date /
     * number ranges) and the trigger count badge to match a filter object —
     * defaults to the currently bound `filter`. Call this from the host after
     * changing the bound filter outside the component's own UI (e.g. removing a
     * chip in a view-filters bar) so the dropdown and badge stay in sync.
     */
    syncFromFilter(filter?: object): void;
    apply(): void;
    private updateAppliedState;
    /**
     * Builds a filter object from the config items. By default it reads the live
     * in-panel state; pass `source` (another filter object) to derive the SAME-
     * shaped object from that source instead — used to compare the current
     * selection against a default preset without duplicating the per-type rules.
     */
    private getFilterObject;
    hide(): void;
    radioChanged(value: string, item: FiltersConfigItem): void;
    checkChanged(item: DataSource, configItem: FiltersConfigItem): void;
    toggleDsItem(dsItem: DataSource, item: FiltersConfigItem): void;
    toggleSelectAll(item: FiltersConfigItem): void;
    toggle(): void;
    onCheckValidity(item: FiltersConfigItem): boolean;
    /** Whether the item's range is usable, without recording a message. */
    private isRangeValid;
    private addValidationError;
    /** Drop any recorded message and the auto-dismiss timer waiting to do so. */
    private clearValidationErrors;
    getDefaultDateRangeOptions(): {
        name: string;
        dateRange: DateRange;
    }[];
    private sortTreeOrder;
    hasTreeData(configItem: FiltersConfigItem): boolean;
    handleDateRangeOptionClick(item: any, option: any): void;
    handleCustomDateRangeClick(item: any): void;
    handleEndDateChange(item: FiltersConfigItem, date: Date | null): void;
    private computeSelectedCount;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduFilterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduFilterComponent, "zen-filter", never, { "config": { "alias": "config"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "position": { "alias": "position"; "required": false; }; "resetBehavior": { "alias": "resetBehavior"; "required": false; }; "defaultFilter": { "alias": "defaultFilter"; "required": false; }; "isVisible": { "alias": "isVisible"; "required": false; }; "customTrigger": { "alias": "customTrigger"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "label": { "alias": "label"; "required": false; }; "triggerVariant": { "alias": "triggerVariant"; "required": false; }; "showOptions": { "alias": "showOptions"; "required": false; }; "customOptions": { "alias": "customOptions"; "required": false; }; "wrapperBodyClass": { "alias": "wrapperBodyClass"; "required": false; }; "customPosition": { "alias": "customPosition"; "required": false; }; }, { "filterChange": "filterChange"; "isVisibleChange": "isVisibleChange"; }, never, ["*"], false, never>;
}

declare class ZenduGroupsComponent implements OnChanges {
    private _elementRef;
    dataSource: DataSource[];
    filteredDataSource: DataSource[];
    hideSelectAll: boolean;
    isSelectedAll: boolean;
    inline: boolean;
    width: string;
    placeholder: string;
    hideSearch: boolean;
    idProp: string;
    displayProp: string;
    isSelectedAllChange: EventEmitter<boolean>;
    checkedChange: EventEmitter<DataSource>;
    isOpen: boolean;
    openUpward: boolean;
    searchText: string;
    private _searchFilteredDataSource;
    private _treeMap;
    private _childCountCache;
    constructor(_elementRef: ElementRef);
    private getChildren;
    hasChildren(item: any): boolean;
    ngOnChanges(changes: SimpleChanges): void;
    onOutsideClick(event: MouseEvent): void;
    toggleDropdown(): void;
    private shouldOpenUpward;
    get displayDataSource(): DataSource[];
    onSearchChange(): void;
    get selectedCount(): number;
    get selectedLabel(): string;
    get hasActiveItems(): boolean;
    onSelectAll(): void;
    onCheckChanged(dsItem: DataSource): void;
    private buildTreeLevels;
    sortTreeOrder(items: DataSource[]): DataSource[];
    isTreeItemVisible(dsItem: DataSource): boolean;
    toggleTreeNode(dsItem: DataSource): void;
    getChildCount(dsItem: DataSource): number;
    isTreeItemIndeterminate(dsItem: DataSource): boolean;
    private getAllDescendants;
    private updateParentCheckedState;
    private cascadeToChildren;
    getTreeConnectors(dsItem: DataSource): string[];
    getTreeMap(): Map<string | number, DataSource>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduGroupsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduGroupsComponent, "zen-groups", never, { "dataSource": { "alias": "dataSource"; "required": false; }; "filteredDataSource": { "alias": "filteredDataSource"; "required": false; }; "hideSelectAll": { "alias": "hideSelectAll"; "required": false; }; "isSelectedAll": { "alias": "isSelectedAll"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; "width": { "alias": "width"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "hideSearch": { "alias": "hideSearch"; "required": false; }; "idProp": { "alias": "idProp"; "required": false; }; "displayProp": { "alias": "displayProp"; "required": false; }; }, { "isSelectedAllChange": "isSelectedAllChange"; "checkedChange": "checkedChange"; }, never, never, false, never>;
}

type PageItem = {
    kind: 'page';
    page: number;
    active: boolean;
} | {
    kind: 'ellipsis';
};

declare class ZenduPaginationBarComponent implements OnChanges {
    page: number;
    perPage: number;
    count: number;
    perPageOptions: number[];
    pageChange: EventEmitter<number>;
    perPageChange: EventEmitter<number>;
    totalPages: number;
    pages: PageItem[];
    rangeStart: number;
    rangeEnd: number;
    ngOnChanges(changes: SimpleChanges): void;
    goToPage(target: number): void;
    onPerPageChange(value: number): void;
    private recalculate;
    private buildPages;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduPaginationBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduPaginationBarComponent, "zen-pagination-bar", never, { "page": { "alias": "page"; "required": false; }; "perPage": { "alias": "perPage"; "required": false; }; "count": { "alias": "count"; "required": false; }; "perPageOptions": { "alias": "perPageOptions"; "required": false; }; }, { "pageChange": "pageChange"; "perPageChange": "perPageChange"; }, never, never, false, never>;
}

interface ColumnState {
    template?: string;
    displayName: string;
    sortKey?: string;
    isVisible: boolean;
    class?: string;
    id?: string;
}

declare class ZenduColumnConfigurationComponent implements OnChanges {
    private _element;
    /**
     * callback to emit changes for parent component
     */
    configurationChange: EventEmitter<ColumnState[]>;
    /**
     * input propery
     */
    configuration: ColumnState[];
    /**
     * Default configuration for reset button
     */
    defaultConfiguration: ColumnState[];
    /**
     * dropdown position
     */
    dropdownPosition: 'right' | 'left';
    /**
     * Inital configuration
     */
    private _sourceConfiguration;
    tempColumnConfiguration: ColumnState[];
    filteredColumnsConfiguration: ColumnState[];
    showPanel: boolean;
    searchText: string;
    constructor(_element: ElementRef);
    outsideHandling(event: any): void;
    ngOnChanges(changes: any): void;
    initData(): void;
    togglePanel(): void;
    apply(): void;
    hide(): void;
    onDrop(event: CdkDragDrop<string[]>): void;
    reset(): void;
    filterItems(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduColumnConfigurationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduColumnConfigurationComponent, "zen-column-configuration", never, { "configuration": { "alias": "configuration"; "required": false; }; "defaultConfiguration": { "alias": "defaultConfiguration"; "required": false; }; "dropdownPosition": { "alias": "dropdownPosition"; "required": false; }; }, { "configurationChange": "configurationChange"; }, never, never, false, never>;
}

declare class ZenduSortHeaderComponent {
    sort: 'asc' | 'desc' | '';
    sortChange: EventEmitter<"desc" | "asc">;
    active: boolean;
    toggleSort(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSortHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduSortHeaderComponent, "zen-sort", never, { "sort": { "alias": "sort"; "required": false; }; "active": { "alias": "active"; "required": false; }; }, { "sortChange": "sortChange"; }, never, never, false, never>;
}

declare class ZenduPhoneInputComponent implements OnInit, OnChanges {
    inputElement: ElementRef<HTMLInputElement>;
    phone: string;
    maxLength: number;
    phoneChange: EventEmitter<string>;
    validChange: EventEmitter<boolean>;
    disabled: boolean;
    width: string;
    phoneText: string;
    countryList: {
        countryCode: string;
        countryName: string;
        countryCallingCode: string;
        flag: string;
    }[];
    customCountry: {
        countryCode: string;
        countryName: string;
        countryCallingCode: string;
        flag: string;
    };
    selectedCountry: {
        countryCode: string;
        countryName: string;
        countryCallingCode: string;
        flag: string;
    };
    isExpanded: boolean;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    parseNumber(): void;
    countryChanged(country: any): void;
    phoneChanged(input?: HTMLInputElement): void;
    hideDropDown(): void;
    toggle(): void;
    focusInput(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduPhoneInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduPhoneInputComponent, "zen-phone-input", never, { "phone": { "alias": "phone"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "phoneChange": "phoneChange"; "validChange": "validChange"; }, never, never, false, never>;
}

declare class ZenduColorPickerComponent implements OnChanges, OnDestroy {
    private _element;
    private _cdr;
    private _zone;
    color: string;
    colorChange: EventEmitter<string>;
    icon: string;
    customTarget: HTMLElement;
    showNone: boolean;
    opened: boolean;
    menuLeft: string;
    menuTop: string;
    menuBottom: string;
    colorsRows: {
        colors: string[];
    }[];
    private _boundTarget;
    private _positionRafId;
    outsideHandling(event: any): void;
    constructor(_element: ElementRef, _cdr: ChangeDetectorRef, _zone: NgZone);
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    toggleEvent(evt: MouseEvent): void;
    toggle(): void;
    updatePlacement(): void;
    /** The element the palette is placed against. */
    private anchorElement;
    private menuElement;
    private addRepositionListeners;
    private removeRepositionListeners;
    private _onViewportChange;
    /**
     * Re-place the open palette on the next frame, coalescing a burst of scroll
     * events into one pass. `closeWhenHidden` is only set for viewport-driven
     * passes: the trigger moving out of view is a reason to close, but a trigger
     * that has not been measured yet is not.
     */
    private scheduleFrame;
    /**
     * Whether the trigger is still on screen AND still inside whatever container
     * it scrolls in — the viewport test alone cannot see a clipping panel.
     */
    private isAnchorVisible;
    private scrollParent;
    private bindCustomTarget;
    private unbindCustomTarget;
    private _toggleFromTarget;
    private hidePicker;
    selectColor(color: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduColorPickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduColorPickerComponent, "zen-colorpicker", never, { "color": { "alias": "color"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "customTarget": { "alias": "customTarget"; "required": false; }; "showNone": { "alias": "showNone"; "required": false; }; }, { "colorChange": "colorChange"; }, never, never, false, never>;
}

declare class ZenduRadioButtonComponent implements OnInit {
    selected: boolean;
    radioChange: EventEmitter<string>;
    label: string;
    value: string;
    name: string;
    disabled: boolean;
    imageUrl: string;
    size: 'sm' | 'md';
    supportingText: string;
    selectedRadio: string;
    constructor();
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    emitChange(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduRadioButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduRadioButtonComponent, "zen-radio", never, { "selected": { "alias": "selected"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "imageUrl": { "alias": "imageUrl"; "required": false; }; "size": { "alias": "size"; "required": false; }; "supportingText": { "alias": "supportingText"; "required": false; }; }, { "radioChange": "radioChange"; }, never, never, false, never>;
}

interface ZenIconConfig {
    iconBasePath: string;
}
declare const ZEN_ICON_CONFIG: InjectionToken<ZenIconConfig>;
type ZenIconSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
type ZenIconColor = 'primary' | 'gray' | 'error' | 'warning' | 'success';
type ZenIconTheme = 'light-circle' | 'light-circle-outline' | 'dark-circle' | 'light-square' | 'mid-square' | 'dark-square';

declare class ZenduIconComponent implements OnChanges {
    private _host;
    private _config;
    src: string;
    name: string;
    size: ZenIconSize;
    color: ZenIconColor;
    theme: ZenIconTheme;
    customColor: string;
    resolvedSrc: string;
    isFeatured: boolean;
    constructor(_host: ElementRef, _config: ZenIconConfig);
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduIconComponent, "zen-icon", never, { "src": { "alias": "src"; "required": false; }; "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "customColor": { "alias": "customColor"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenduCardBlockComponent {
    icon: string;
    title: string;
    text: string;
    selected: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduCardBlockComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduCardBlockComponent, "zen-card-block", never, { "icon": { "alias": "icon"; "required": false; }; "title": { "alias": "title"; "required": false; }; "text": { "alias": "text"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenduMapPreviewComponent implements OnChanges {
    lat: number;
    lng: number;
    apiKey: string;
    source: string;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduMapPreviewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduMapPreviewComponent, "zen-map-preview", never, { "lat": { "alias": "lat"; "required": false; }; "lng": { "alias": "lng"; "required": false; }; "apiKey": { "alias": "apiKey"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenduSpinner {
    size?: "small" | "default";
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSpinner, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduSpinner, "zen-spinner", never, { "size": { "alias": "size"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ScriptLoader {
    private static _loadedLibs;
    private static _lock;
    loadScript(lib: "flv" | "opencv" | "jscanify"): Promise<void>;
    private loadScriptBySrc;
    private waitInitalization;
    private getCVInternal;
    static ɵfac: i0.ɵɵFactoryDeclaration<ScriptLoader, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ScriptLoader>;
}

interface ScanifyCorners {
    topLeftCorner: {
        x: number;
        y: number;
    };
    topRightCorner: {
        x: number;
        y: number;
    };
    bottomLeftCorner: {
        x: number;
        y: number;
    };
    bottomRightCorner: {
        x: number;
        y: number;
    };
}
declare class OpenCVService {
    private _scriptLoader;
    private static _isOpenCVLoaded;
    private static _lock;
    constructor(_scriptLoader: ScriptLoader);
    /**
     * extract paper from the image
     * @returns
     */
    extractPaper(options: {
        src: string;
        height: number;
        width: number;
        corners: ScanifyCorners;
    }): Promise<HTMLCanvasElement>;
    /**
     * Get the paper corners from the specific image
     * @param src
     * @returns
     */
    getPaperCorners(src: string, height: number, width: number): Promise<ScanifyCorners>;
    private loadImage;
    private loadOpenCv;
    private getCVInternal;
    static ɵfac: i0.ɵɵFactoryDeclaration<OpenCVService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<OpenCVService>;
}

declare class ZenduDocScanner implements AfterViewInit, OnChanges {
    private _opencv;
    private cdRef;
    _canvasElement: ElementRef<HTMLCanvasElement>;
    _component: ElementRef<HTMLDivElement>;
    src: string;
    width: number;
    height: number;
    isScanStart: boolean;
    canAddText: boolean;
    canDoodle: boolean;
    currentStateIndex: number;
    isLoading: BehaviorSubject<boolean>;
    canvasStates: {
        state: string;
        customControl: any;
    }[];
    isResize: boolean;
    initialMouseY: number;
    originalFontSize: number;
    isRedoing: boolean;
    isUndoing: boolean;
    expandIconSrc: string;
    rotateIconSrc: string;
    crossIconSrc: string;
    set done(completed: boolean);
    extracted: EventEmitter<HTMLCanvasElement>;
    cornersChanged: EventEmitter<void>;
    getUndoingChange: EventEmitter<boolean>;
    getRedoingChange: EventEmitter<boolean>;
    canAddTextOrDoole: EventEmitter<{}>;
    canRedoOrUndo: EventEmitter<{
        canRedo: boolean;
        canUndo: boolean;
    }>;
    private screenPoints;
    private _canvas;
    private _cornersPg;
    private _scaleFactor;
    private _controls;
    selectedColor: string;
    isScaned: boolean;
    textAdded: boolean;
    icons: {
        cross: HTMLImageElement;
        rotate: HTMLImageElement;
        expand: HTMLImageElement;
    };
    private Image;
    borderWidth: number;
    colors: {
        hexCode: string;
        selected: boolean;
    }[];
    resizeIcon: HTMLElement;
    rotateIcon: HTMLElement;
    removeIcon: HTMLElement;
    constructor(_opencv: OpenCVService, cdRef: ChangeDetectorRef);
    ngAfterViewInit(): void;
    onCanvasEdit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    chngClrTextOrBrush(color: string, changeFor: string): void;
    addPointsTodoc(): Promise<void>;
    private init;
    createCanvas(): Promise<void>;
    renderIcon(ctx: CanvasRenderingContext2D, left: number, top: number, styleOverride: any, fabricObject: fabric.Object, iconName: string): void;
    stopResizeText(event: any): void;
    resizeText(event: any): void;
    addTextOnClick(event: any): void;
    addTextBox(event: any): void;
    scaleFunction(eventData: MouseEvent, transform: Transform, x: number, y: number): void;
    saveCanvasState(): void;
    redo(): void;
    undo(): void;
    private getCanvasSize;
    /**
     * recognize paper corners
     */
    private build;
    private createControls;
    private createControl;
    private loadBackgroundImage;
    completeScan(completed: boolean): Promise<void>;
    private cleanupCanvas;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduDocScanner, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduDocScanner, "zen-doc-scanner", never, { "src": { "alias": "src"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "isScanStart": { "alias": "isScanStart"; "required": false; }; "canAddText": { "alias": "canAddText"; "required": false; }; "canDoodle": { "alias": "canDoodle"; "required": false; }; "isRedoing": { "alias": "isRedoing"; "required": false; }; "isUndoing": { "alias": "isUndoing"; "required": false; }; "expandIconSrc": { "alias": "expandIconSrc"; "required": false; }; "rotateIconSrc": { "alias": "rotateIconSrc"; "required": false; }; "crossIconSrc": { "alias": "crossIconSrc"; "required": false; }; "done": { "alias": "done"; "required": false; }; }, { "extracted": "extracted"; "cornersChanged": "cornersChanged"; "getUndoingChange": "getUndoingChange"; "getRedoingChange": "getRedoingChange"; "canAddTextOrDoole": "canAddTextOrDoole"; "canRedoOrUndo": "canRedoOrUndo"; }, never, never, false, never>;
}

interface ZenLogRecord {
    /**
     * The date and time the log was recorded.
     */
    dateTime?: string;
    /**
     * The latitude of the log record.
     */
    latitude: number;
    /**
     *  The longitude of the log record.
     */
    longitude: number;
    /**
     * Speed
     */
    speed?: number;
}
interface ZenTrip {
    logs: ZenLogRecord[];
}
interface ZenDevice {
    /**
     * the custom device icon
     */
    icon?: string;
    name: string;
    bearing?: number;
    isDriving?: boolean;
    latitude: number;
    longitude: number;
}
type ZenMapTheme = "black" | "default";

declare class ZenduMapComponent implements OnChanges {
    _mapElement: ElementRef<HTMLDivElement>;
    apiKey: string;
    trips: ZenTrip[];
    devices: ZenDevice[];
    theme: ZenMapTheme;
    private _platform;
    private _map;
    private _objects;
    private _mapService;
    ngOnChanges(changes: SimpleChanges): void;
    private init;
    private initMap;
    private updateEntities;
    private createTrips;
    private createDevices;
    private clearEntities;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduMapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduMapComponent, "zen-map", never, { "apiKey": { "alias": "apiKey"; "required": false; }; "trips": { "alias": "trips"; "required": false; }; "devices": { "alias": "devices"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenduFileUpload {
    fileTypes: string;
    uploadState: "" | "uploading" | "done";
    /**
     * fire when user clicked on "Upload now"
     */
    uploadFile: EventEmitter<File[]>;
    /**
     * fired when user click "Cancel"
     */
    uploadCancelled: EventEmitter<void>;
    isFileSelected: boolean;
    isFileDragover: boolean;
    filename: string;
    private _selectedFiles;
    onDragOver(evt: Event): void;
    onDragLeave(evt: Event): void;
    ondrop(evt: DragEvent): void;
    onFileInput(evt: Event): Promise<void>;
    handleFiles(files: FileList): Promise<void>;
    uploadNow(): void;
    clear(): void;
    cancelUploading(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduFileUpload, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduFileUpload, "zen-file-upload", never, { "fileTypes": { "alias": "fileTypes"; "required": false; }; "uploadState": { "alias": "uploadState"; "required": false; }; }, { "uploadFile": "uploadFile"; "uploadCancelled": "uploadCancelled"; }, never, never, false, never>;
}

interface CircleSizeConfig {
    containerSize: number;
    radius: number;
    strokeWidth: number;
    fontSize: number;
    labelFontSize: number;
    letterSpacing: number;
}
declare class ZenduProgress {
    type: "bar" | "circle" | "half-circle";
    /**
     * Label position for bar type.
     */
    label: 'none' | 'right' | 'bottom' | 'top-floating' | 'bottom-floating';
    /**
     * Size for circle/half-circle types.
     */
    size: 'xxs' | 'xs' | 'sm' | 'md' | 'lg';
    /**
     * progress value [0, 100]
     */
    value: number;
    /**
     * progress text (shown as label above percentage in circle types)
     */
    text: string;
    /**
     * Custom color for the progress fill (bar, circle stroke).
     * Accepts any valid CSS color value.
     */
    color: string;
    /**
     * Custom color for the progress track/background.
     * Accepts any valid CSS color value.
     */
    trackColor: string;
    get sizeConfig(): CircleSizeConfig;
    get circleCenter(): number;
    get circumference(): number;
    get halfCircumference(): number;
    get circleOffset(): number;
    get halfCircleOffset(): number;
    get halfCircleContainerHeight(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduProgress, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduProgress, "zen-progress", never, { "type": { "alias": "type"; "required": false; }; "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; "value": { "alias": "value"; "required": false; }; "text": { "alias": "text"; "required": false; }; "color": { "alias": "color"; "required": false; }; "trackColor": { "alias": "trackColor"; "required": false; }; }, {}, never, never, false, never>;
}

interface IGeocodingRes {
    name: string;
    city: string;
    country: string;
    postalCode: string;
    street: string;
    state: string;
    bounds: {
        xmin: number;
        ymin: number;
        xmax: number;
        ymax: number;
    };
}
declare class GeocodingService {
    private _platform;
    setAPIKey(apiKey: string): void;
    geocode(searchText: string): Promise<Array<IGeocodingRes>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<GeocodingService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<GeocodingService>;
}

interface LocationAddress {
    name: string;
    bounds: {
        xmin: number;
        ymin: number;
        xmax: number;
        ymax: number;
    };
}
interface Cancellation {
    cancelled: boolean;
}

declare class ZenduLocationSearch {
    private _geocoding;
    private _cdRef;
    /**
     * HERE MAPS API Key
     */
    set apiKey(apiKey: string);
    address: string;
    displaySearchIcon: boolean;
    addressChange: EventEmitter<string>;
    materialStyle: boolean;
    placeholder: string;
    disabled: boolean;
    onSelect: EventEmitter<LocationAddress>;
    customStyles: any;
    private addressSearchChanged;
    isSearching: boolean;
    ignoreFirstLoad: boolean;
    addressList: LocationAddress[];
    private _cancelation;
    constructor(_geocoding: GeocodingService, _cdRef: ChangeDetectorRef);
    ngOnChanges(changes: SimpleChanges): Promise<void>;
    addressChanged(text: string): void;
    private makeSearch;
    selectAddress(address: LocationAddress): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduLocationSearch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduLocationSearch, "zen-location-search", never, { "apiKey": { "alias": "apiKey"; "required": false; }; "address": { "alias": "address"; "required": false; }; "displaySearchIcon": { "alias": "displaySearchIcon"; "required": false; }; "materialStyle": { "alias": "materialStyle"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "customStyles": { "alias": "customStyles"; "required": false; }; }, { "addressChange": "addressChange"; "onSelect": "onSelect"; }, never, never, false, never>;
}

declare class PlayerControl {
    private _stopEvent;
    private _playEvent;
    private _seekEvent;
    private _dataEvent;
    /**
     * Subscribe to data event
     */
    OnData(callback: () => void): number;
    /**
     * Subscribe to play event
     */
    OnPlay(callback: () => void): number;
    /**
     * Subscribe to stop event
     */
    OnStop(callback: () => void): number;
    /**
     * Subscribe to seek event
     */
    OnSeek(callback: (position: number) => void): number;
    /**
     * Detach the callback from the event
     * @param id callback id
     */
    OffPlay(id: number): void;
    /**
     * Detach the callback from the event
     * @param id callback id
     */
    OffStop(id: number): void;
    /**
     * Detach the callback from the event
     * @param id callback id
     */
    OffSeek(id: number): void;
    /**
     * Emit the play event
     */
    Play(): void;
    /**
     * Emit the stop event
     */
    Stop(): void;
    /**
     * Emit the seek event
     */
    Seek(position: number): void;
    /**
     * Emit the data event
     */
    EmitData(): void;
}

type ZenLiveViewPlayerType = 'html5' | 'flv' | 'webrtc' | 'snapshot' | 'hls' | 'unknown';
declare class ZenLiveViewPlayerComponent implements OnDestroy {
    control: PlayerControl;
    source: string;
    playerType: ZenLiveViewPlayerType;
    snapshotInterval: number;
    /**
     * Playback timeout. It uses for streamax live streaming.
     */
    timeout: number;
    onData: EventEmitter<void>;
    private _controlPlayHander;
    private _controlStopHander;
    IsLoading: boolean;
    constructor();
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenLiveViewPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenLiveViewPlayerComponent, "zen-live-view-player", never, { "control": { "alias": "control"; "required": false; }; "source": { "alias": "source"; "required": false; }; "playerType": { "alias": "playerType"; "required": false; }; "snapshotInterval": { "alias": "snapshotInterval"; "required": false; }; "timeout": { "alias": "timeout"; "required": false; }; }, { "onData": "onData"; }, never, never, false, never>;
}

declare class ZenHTML5VideoPlayerComponent implements OnChanges {
    source: string;
    control: PlayerControl;
    ngOnChanges(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenHTML5VideoPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenHTML5VideoPlayerComponent, "zen-html5-video-player", never, { "source": { "alias": "source"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenFlvPlayerComponent implements OnDestroy, OnChanges {
    private _element;
    private _scriptLoader;
    source: string;
    control?: PlayerControl;
    private _flv;
    IsVideoFilterVisible: boolean;
    constructor(_element: ElementRef, _scriptLoader: ScriptLoader);
    ngOnChanges(changeObj: any): void;
    ngOnDestroy(): void;
    private reload;
    private update;
    private destroy;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenFlvPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenFlvPlayerComponent, "zen-flv-player", never, { "source": { "alias": "source"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenHlsPlayerComponent implements OnDestroy, OnChanges {
    source: string;
    control: PlayerControl;
    _video?: ElementRef<HTMLVideoElement>;
    isVideoFilterVisible: boolean;
    private _hls;
    private _stopCallback;
    private _playCallback;
    private _isDestroyed;
    ngOnChanges(changeObj: any): void;
    ngOnDestroy(): void;
    private reload;
    private waitForComponent;
    private setControl;
    private destroy;
    private onData;
    private onError;
    toggleFilter(evt: MouseEvent): void;
    hideFiler(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenHlsPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenHlsPlayerComponent, "zen-hls-player", never, { "source": { "alias": "source"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenHttpService {
    private _http;
    private cache;
    constructor(_http: HttpClient);
    /**
     * https post request
     * @param url the url path
     * @param data the POST payload
     * @param cacheTtl cache ttl in ms
     * @param retires number of retires
     * @returns
     */
    post<T>(url: string, data?: unknown, cacheTtl?: number, retires?: number): Promise<T>;
    private doCachedPost;
    private doPost;
    get<T>(url: string, timeout?: number): Promise<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenHttpService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ZenHttpService>;
}

declare class ZenSnapshotPlayerComponent implements OnChanges, OnDestroy {
    private _http;
    source: string;
    channel: number;
    control?: PlayerControl;
    /**
     * Interval to render a snapshot
     */
    interval: number;
    snapshot: string;
    private _timer;
    private _isRunning;
    IsVideoFilterVisible: boolean;
    private _isDestroyed;
    constructor(_http: ZenHttpService);
    ngOnDestroy(): void;
    ngOnChanges(changeObj: any): void;
    private setControl;
    private update;
    private startPlay;
    private render;
    private renderFrame;
    private stopPlay;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenSnapshotPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenSnapshotPlayerComponent, "zen-snapshot-player", never, { "source": { "alias": "source"; "required": false; }; "channel": { "alias": "channel"; "required": false; }; "control": { "alias": "control"; "required": false; }; "interval": { "alias": "interval"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenWebRTCPlayerComponent implements OnChanges, OnDestroy {
    private _element;
    source: string;
    control?: PlayerControl;
    onStartPlay: EventEmitter<void>;
    onServerError: EventEmitter<void>;
    onServerDisconnect: EventEmitter<void>;
    IsLoading: boolean;
    IsVideoFilterVisible: boolean;
    private _webrtc;
    private _isDestroyed;
    constructor(_element: ElementRef);
    ngOnDestroy(): void;
    ngOnChanges(changeObj: any): void;
    private createWebRTC;
    private stopPlayback;
    private Play;
    private getVideoElement;
    private invokeOnStartPlay;
    private invokeOnData;
    private invokeOnServerError;
    private invokeOnServerDisconnect;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenWebRTCPlayerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenWebRTCPlayerComponent, "zen-web-rtc-player", never, { "source": { "alias": "source"; "required": false; }; "control": { "alias": "control"; "required": false; }; }, { "onStartPlay": "onStartPlay"; "onServerError": "onServerError"; "onServerDisconnect": "onServerDisconnect"; }, never, never, false, never>;
}

type TimePickerMode = 'clock' | 'duration';
interface TimePickerValue {
    hours: number;
    minutes: number;
    seconds: number;
    period?: 'AM' | 'PM';
}
declare class ZenduTimepickerComponent implements OnInit, OnChanges {
    private _element;
    mode: TimePickerMode;
    label: string;
    value: TimePickerValue;
    showSeconds: boolean;
    showHours: boolean;
    disabled: boolean;
    readonly: boolean;
    placeholder: string;
    width: string;
    valueChange: EventEmitter<TimePickerValue>;
    apply: EventEmitter<TimePickerValue>;
    clear: EventEmitter<void>;
    isPickerVisible: boolean;
    selectedHours: number;
    selectedMinutes: number;
    selectedSeconds: number;
    selectedPeriod: 'AM' | 'PM';
    hoursDisplay: string;
    minutesDisplay: string;
    secondsDisplay: string;
    right: boolean;
    bottom: boolean;
    private maxHour;
    private minHour;
    constructor(_element: ElementRef);
    outsideClick(event: MouseEvent): void;
    get defaultLabel(): string;
    get defaultPlaceholder(): string;
    get formattedDisplayValue(): string;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    togglePicker(): void;
    incrementHours(): void;
    decrementHours(): void;
    incrementMinutes(): void;
    decrementMinutes(): void;
    incrementSeconds(): void;
    decrementSeconds(): void;
    onHoursInput(event: Event): void;
    onMinutesInput(event: Event): void;
    onSecondsInput(event: Event): void;
    onFocus(event: Event): void;
    clampHours(): void;
    clampMinutes(): void;
    clampSeconds(): void;
    onInputKeydown(event: KeyboardEvent, type: 'hours' | 'minutes' | 'seconds'): void;
    selectPeriod(period: 'AM' | 'PM'): void;
    formatNum(n: number): string;
    onApply(): void;
    onClear(): void;
    private updatePlacement;
    private updateHourLimits;
    private applyValue;
    private getCurrentValue;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduTimepickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduTimepickerComponent, "zen-timepicker", never, { "mode": { "alias": "mode"; "required": false; }; "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "showSeconds": { "alias": "showSeconds"; "required": false; }; "showHours": { "alias": "showHours"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "valueChange": "valueChange"; "apply": "apply"; "clear": "clear"; }, never, never, false, never>;
}

type DatePickerDropdownType = 'single' | 'range';
interface DatePickerPreset {
    label: string;
    getRange: () => {
        start: Date;
        end: Date;
    };
}
declare const ZEN_DATE_PICKER_DEFAULT_PRESETS: InjectionToken<DatePickerPreset[]>;
interface DateRangeValue {
    start: Date | null;
    end: Date | null;
}
interface DatePickerMarker {
    title?: string;
    color?: string;
    dates: number[];
}

declare class ZenduDatePickerDropdownComponent implements OnInit, OnChanges, OnDestroy {
    private _element;
    private _translate;
    type: DatePickerDropdownType;
    date: Date | null;
    dateChange: EventEmitter<Date>;
    startDate: Date | null;
    startDateChange: EventEmitter<Date>;
    endDate: Date | null;
    endDateChange: EventEmitter<Date>;
    rangeChange: EventEmitter<DateRangeValue>;
    presets: DatePickerPreset[] | null;
    minDate: Date | null;
    maxDate: Date | null;
    disabled: boolean;
    dateMarkers: DatePickerMarker[];
    placeholder: string;
    mobileBreakpoint: number;
    timePicker: boolean;
    autoApply: boolean;
    /**
     * Hide the built-in trigger button. The popup then anchors to the host
     * element, so an external control (e.g. a select) can drive it via open().
     */
    hideTrigger: boolean;
    /** Field label rendered above the trigger. Pass an already-translated
     *  string (e.g. `[label]="'Select Date' | translate"`) — not translated
     *  internally. */
    label: string;
    /** Adds a red `*` to the label. */
    required: boolean;
    /** Trigger height: `md` (40px, default, matches the md button) or `form`
     *  (46px, to sit flush in a 46px-tall form field row). */
    size: 'md' | 'form';
    triggerBtn?: ElementRef;
    mobile: boolean;
    isOpen: boolean;
    dropdownStyle: {
        [key: string]: string;
    };
    private _positionRafId;
    leftCurrentSlot: Date;
    leftDayRows: Array<{
        days: DatePickerDay[];
    }>;
    leftDaysTitle: string;
    rightCurrentSlot: Date;
    rightDayRows: Array<{
        days: DatePickerDay[];
    }>;
    rightDaysTitle: string;
    weekDays: string[];
    _selectedDate: Date | null;
    _selectedStart: Date | null;
    _selectedEnd: Date | null;
    _activePreset: string | null;
    _appliedPresetLabel: string | null;
    _appliedPresetStartTime: number | null;
    _appliedPresetEndTime: number | null;
    _hours: number;
    _minutes: number;
    _period: 'AM' | 'PM';
    _hoursDisplay: string;
    _minutesDisplay: string;
    _endHours: number;
    _endMinutes: number;
    _endPeriod: 'AM' | 'PM';
    _endHoursDisplay: string;
    _endMinutesDisplay: string;
    defaultPresets: DatePickerPreset[];
    constructor(_element: ElementRef, _translate: TranslateService, globalPresets: DatePickerPreset[] | null);
    ngOnInit(): void;
    onResize(): void;
    private checkMobile;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    outsideHandling(event: MouseEvent): void;
    get activePresets(): DatePickerPreset[];
    get showPresetsSidebar(): boolean;
    get showDualCalendars(): boolean;
    get triggerLabel(): string;
    private matchingPresetLabel;
    get legendMarkers(): DatePickerMarker[];
    get hasValue(): boolean;
    get formattedSelectedDate(): string;
    get formattedStartDate(): string;
    get formattedEndDate(): string;
    formatDate(date: Date, includeTime?: boolean): string;
    private formatTime;
    toggle(): void;
    open(): void;
    private updateDropdownPosition;
    /**
     * Re-clamp the open panel to the viewport using its real measured size.
     * Keeps the panel anchored to the trigger and guarantees the footer stays
     * reachable (the panel scrolls internally) at any viewport size or zoom.
     */
    private clampToViewport;
    /**
     * The panel is `position: fixed`, so its coordinates are viewport-relative
     * ONLY when no ancestor establishes a containing block. Inside a CDK
     * overlay pane (e.g. when this picker sits in a `zen-filter`), the pane is
     * `transform`ed and becomes the containing block, so `fixed` is measured
     * from the pane, not the viewport — which detaches the panel from its
     * trigger. Return that containing block's viewport rect so the
     * viewport-space coordinates above can be offset into the panel's actual
     * coordinate space; falls back to the viewport when nothing transforms.
     */
    private containingBlockRect;
    /**
     * Anchor to the trigger button, or to the host element when the trigger is
     * hidden (an external control drives the popup).
     */
    private anchorElement;
    private addRepositionListeners;
    private removeRepositionListeners;
    private _onViewportChange;
    private schedulePositionUpdate;
    close(): void;
    leftPrevMonth(): void;
    leftNextMonth(): void;
    rightPrevMonth(): void;
    rightNextMonth(): void;
    prevMonth(): void;
    nextMonth(): void;
    selectDay(day: DatePickerDay): void;
    selectPreset(preset: DatePickerPreset): void;
    goToToday(): void;
    private formatNum;
    incrementHours(target?: 'start' | 'end'): void;
    decrementHours(target?: 'start' | 'end'): void;
    incrementMinutes(target?: 'start' | 'end'): void;
    decrementMinutes(target?: 'start' | 'end'): void;
    onHoursInput(event: Event, target?: 'start' | 'end'): void;
    onMinutesInput(event: Event, target?: 'start' | 'end'): void;
    clampHours(target?: 'start' | 'end'): void;
    clampMinutes(target?: 'start' | 'end'): void;
    onTimeFocus(event: Event): void;
    onTimeKeydown(event: KeyboardEvent, type: 'hours' | 'minutes', target?: 'start' | 'end'): void;
    setPeriod(period: 'AM' | 'PM', target?: 'start' | 'end'): void;
    private applyTimeToDate;
    private initTimeFromDate;
    apply(): void;
    cancel(): void;
    get canApply(): boolean;
    private updateCalendars;
    /**
     * "October 2026" in the app language ("Octubre de 2026" in Spanish), via Intl
     * rather than a global moment.locale(). The short-month translation keys can't
     * be reused here: "May" is both the short and the full English name.
     */
    private formatMonthTitle;
    private updateDays;
    private isDaySelected;
    isToday(day: DatePickerDay): boolean;
    isInRange(day: DatePickerDay): boolean;
    isRangeStart(day: DatePickerDay): boolean;
    isRangeEnd(day: DatePickerDay): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduDatePickerDropdownComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduDatePickerDropdownComponent, "zen-date-picker-dropdown", never, { "type": { "alias": "type"; "required": false; }; "date": { "alias": "date"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "presets": { "alias": "presets"; "required": false; }; "minDate": { "alias": "minDate"; "required": false; }; "maxDate": { "alias": "maxDate"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "dateMarkers": { "alias": "dateMarkers"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "mobileBreakpoint": { "alias": "mobileBreakpoint"; "required": false; }; "timePicker": { "alias": "timePicker"; "required": false; }; "autoApply": { "alias": "autoApply"; "required": false; }; "hideTrigger": { "alias": "hideTrigger"; "required": false; }; "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, { "dateChange": "dateChange"; "startDateChange": "startDateChange"; "endDateChange": "endDateChange"; "rangeChange": "rangeChange"; }, never, never, false, never>;
}

interface FileUploadItem {
    file: File;
    progress: number;
    status: 'uploading' | 'complete' | 'error';
    fileType: 'document' | 'video' | 'misc';
}
type FileUploaderProgressType = 'bar' | 'fill';

declare class ZenduFileUploaderComponent {
    accept: string;
    multiple: boolean;
    maxFileSize: number;
    disabled: boolean;
    description: string;
    progressType: FileUploaderProgressType;
    files: FileUploadItem[];
    filesSelected: EventEmitter<File[]>;
    fileRemoved: EventEmitter<FileUploadItem>;
    fileInput: ElementRef<HTMLInputElement>;
    isDragover: boolean;
    onDragOver(evt: DragEvent): void;
    onDragLeave(evt: DragEvent): void;
    onDrop(evt: DragEvent): void;
    openFileDialog(): void;
    onFileInput(evt: Event): void;
    removeFile(item: FileUploadItem): void;
    getFileIcon(fileType: string): string;
    formatFileSize(bytes: number): string;
    private filterFiles;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduFileUploaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduFileUploaderComponent, "zen-file-uploader", never, { "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "description": { "alias": "description"; "required": false; }; "progressType": { "alias": "progressType"; "required": false; }; "files": { "alias": "files"; "required": false; }; }, { "filesSelected": "filesSelected"; "fileRemoved": "fileRemoved"; }, never, never, false, never>;
}

type ZenduAvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl';
type ZenduAvatarStatusIcon = 'none' | 'online' | 'company';
declare class ZenduAvatarComponent {
    size: ZenduAvatarSize;
    src: string;
    text: string;
    statusIcon: ZenduAvatarStatusIcon;
    companyImgSrc: string;
    focused: boolean;
    get showImage(): boolean;
    get showText(): boolean;
    get showPlaceholder(): boolean;
    get cssClasses(): Record<string, boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduAvatarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduAvatarComponent, "zendu-avatar", never, { "size": { "alias": "size"; "required": false; }; "src": { "alias": "src"; "required": false; }; "text": { "alias": "text"; "required": false; }; "statusIcon": { "alias": "statusIcon"; "required": false; }; "companyImgSrc": { "alias": "companyImgSrc"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; }, {}, never, never, false, never>;
}

type ZenduAvatarGroupSize = 'xs' | 'sm' | 'md';
declare class ZenduAvatarGroupComponent {
    size: ZenduAvatarGroupSize;
    images: string[];
    moreCount: number;
    showAddButton: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduAvatarGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduAvatarGroupComponent, "zendu-avatar-group", never, { "size": { "alias": "size"; "required": false; }; "images": { "alias": "images"; "required": false; }; "moreCount": { "alias": "moreCount"; "required": false; }; "showAddButton": { "alias": "showAddButton"; "required": false; }; }, {}, never, never, false, never>;
}

type ZenduAvatarLabelGroupSize = 'sm' | 'md' | 'lg' | 'xl';
declare class ZenduAvatarLabelGroupComponent {
    size: ZenduAvatarLabelGroupSize;
    src: string;
    text: string;
    name: string;
    subtitle: string;
    statusIcon: ZenduAvatarStatusIcon;
    companyImgSrc: string;
    focused: boolean;
    get avatarSize(): ZenduAvatarSize;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduAvatarLabelGroupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduAvatarLabelGroupComponent, "zendu-avatar-label-group", never, { "size": { "alias": "size"; "required": false; }; "src": { "alias": "src"; "required": false; }; "text": { "alias": "text"; "required": false; }; "name": { "alias": "name"; "required": false; }; "subtitle": { "alias": "subtitle"; "required": false; }; "statusIcon": { "alias": "statusIcon"; "required": false; }; "companyImgSrc": { "alias": "companyImgSrc"; "required": false; }; "focused": { "alias": "focused"; "required": false; }; }, {}, never, never, false, never>;
}

type ZenduAvatarProfilePhotoSize = 'md' | 'lg';
declare class ZenduAvatarProfilePhotoComponent {
    size: ZenduAvatarProfilePhotoSize;
    src: string;
    text: string;
    get showImage(): boolean;
    get showText(): boolean;
    get showPlaceholder(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduAvatarProfilePhotoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduAvatarProfilePhotoComponent, "zendu-avatar-profile-photo", never, { "size": { "alias": "size"; "required": false; }; "src": { "alias": "src"; "required": false; }; "text": { "alias": "text"; "required": false; }; }, {}, never, never, false, never>;
}

type ZenduSliderLabel = 'none' | 'bottom' | 'bottom-floating' | 'top-floating';
declare class ZenduSliderComponent implements OnDestroy {
    min: number;
    max: number;
    step: number;
    lowValue: number;
    highValue: number;
    label: ZenduSliderLabel;
    suffix: string;
    disabled: boolean;
    lowValueChange: EventEmitter<number>;
    highValueChange: EventEmitter<number>;
    trackRef: ElementRef<HTMLElement>;
    private activeThumb;
    private boundMouseMove;
    private boundMouseUp;
    private boundTouchMove;
    private boundTouchEnd;
    get lowPercent(): number;
    get highPercent(): number;
    formatValue(value: number): string;
    onTrackClick(event: MouseEvent): void;
    onThumbMouseDown(event: MouseEvent, thumb: 'low' | 'high'): void;
    onThumbTouchStart(event: TouchEvent, thumb: 'low' | 'high'): void;
    ngOnDestroy(): void;
    private onMouseMove;
    private onMouseUp;
    private onTouchMove;
    private onTouchEnd;
    private getPercentFromEvent;
    private getPercentFromTouch;
    private percentToValue;
    private updateLow;
    private updateHigh;
    private removeListeners;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduSliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduSliderComponent, "zendu-slider", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "lowValue": { "alias": "lowValue"; "required": false; }; "highValue": { "alias": "highValue"; "required": false; }; "label": { "alias": "label"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "lowValueChange": "lowValueChange"; "highValueChange": "highValueChange"; }, never, never, false, never>;
}

interface DropdownOption {
    label: string;
    value: string | number;
    icon?: string;
}
declare class ZenduInputComponent implements ControlValueAccessor, OnInit, OnChanges {
    inputElement: ElementRef<HTMLInputElement | HTMLTextAreaElement>;
    /**
     * Input type attribute
     */
    type: 'text' | 'email' | 'password' | 'tel' | 'number' | 'url' | 'search';
    /**
     * Input variant type
     */
    variant: 'default' | 'input-field' | 'payment' | 'leading-dropdown' | 'leading-text' | 'trailing-dropdown' | 'trailing-text';
    /**
     * Placeholder text
     */
    placeholder: string;
    /**
     * Label text (shown above input)
     */
    label: string;
    /**
     * Hint text (shown below input)
     */
    hintText: string;
    /**
     * Leading icon name (Material Icons)
     */
    leadingIcon: string;
    /**
     * Show help icon. The tooltip is shown on hover / keyboard focus.
     */
    helpIcon: boolean;
    /**
     * Tooltip text for the help icon (shown on hover / focus).
     */
    helpTooltip: string;
    /**
     * Error/destructive state
     */
    destructive: boolean;
    /**
     * Error message to display
     */
    errorMessage: string;
    /**
     * Disabled state
     */
    disabled: boolean;
    /**
     * Required field
     */
    required: boolean;
    /**
     * Maximum character length
     */
    maxLength: number;
    /**
     * Minimum character length
     */
    minLength: number;
    /**
     * Pattern for validation
     */
    pattern: string;
    /**
     * Minimum value for `type="number"` inputs (maps to the native `min`
     * attribute). Applied to all single-line types but only meaningful for
     * `number`; the browser ignores it otherwise. Not applied to multiline.
     */
    min?: number;
    /**
     * Maximum value for `type="number"` inputs (maps to the native `max`
     * attribute). Applied to all single-line types but only meaningful for
     * `number`; the browser ignores it otherwise. Not applied to multiline.
     */
    max?: number;
    /**
     * Step increment for `type="number"` inputs (maps to the native `step`
     * attribute). Accepts a number or the literal `'any'`.
     */
    step?: number | 'any';
    /**
     * Autocomplete attribute
     */
    autocomplete: string;
    /**
     * Name attribute
     */
    name: string;
    /**
     * ID attribute
     */
    id: string;
    /**
     * Leading dropdown options
     */
    leadingDropdownOptions: DropdownOption[];
    /**
     * Selected leading dropdown value
     */
    leadingDropdownValue: string | number;
    /**
     * Leading dropdown placeholder
     */
    leadingDropdownPlaceholder: string;
    /**
     * Trailing dropdown options
     */
    trailingDropdownOptions: DropdownOption[];
    /**
     * Selected trailing dropdown value
     */
    trailingDropdownValue: string | number;
    /**
     * Trailing dropdown placeholder
     */
    trailingDropdownPlaceholder: string;
    /**
     * Leading static text
     */
    leadingText: string;
    /**
     * Trailing static text
     */
    trailingText: string;
    /**
     * Render a multiline textarea instead of a single-line input.
     * Composes with label/hint/character-count/states; single-line
     * adornments (leading/trailing dropdowns and text) are not used.
     */
    multiline: boolean;
    /**
     * Initial visible rows for the multiline textarea (height is then
     * user-resizable vertically). Only applies when `multiline` is true.
     */
    rows: number;
    /**
     * Whether the multiline textarea can be resized via the footer drag handle.
     * When false, the handle is hidden and the height stays fixed at `rows`.
     */
    resizable: boolean;
    /**
     * Input size
     */
    size: 'sm' | 'md';
    /**
     * Show character counter
     */
    showCharacterCount: boolean;
    /**
     * Phone input maximum length
     */
    phoneMaxLength: number;
    /**
     * Phone number value (for tel type)
     */
    phone: string;
    /**
     * Width for phone input
     */
    width: string;
    /**
     * Value change event for the `[(value)]` two-way binding.
     *
     * NOTE — type contract for `type="number"`: this output always emits the
     * RAW STRING from the input element. The CVA path (`[(ngModel)]` /
     * `formControl`) instead emits a real `number` (or '' when empty/invalid).
     * So a consumer binding BOTH `[(value)]` and ngModel/formControl to the same
     * number input will observe a `string` here and a `number` there for the
     * same edit. Bind only one, and prefer ngModel/formControl when you need the
     * numeric value.
     */
    valueChange: EventEmitter<string>;
    /**
     * Focus event
     */
    inputFocus: EventEmitter<FocusEvent>;
    /**
     * Blur event
     */
    inputBlur: EventEmitter<FocusEvent>;
    /**
     * Keydown event
     */
    inputKeydown: EventEmitter<KeyboardEvent>;
    /**
     * Keyup event
     */
    inputKeyup: EventEmitter<KeyboardEvent>;
    /**
     * Leading dropdown change event
     */
    leadingDropdownChange: EventEmitter<string | number>;
    /**
     * Leading dropdown value change event (for two-way binding)
     */
    leadingDropdownValueChange: EventEmitter<string | number>;
    /**
     * Trailing dropdown change event
     */
    trailingDropdownChange: EventEmitter<string | number>;
    /**
     * Trailing dropdown value change event (for two-way binding)
     */
    trailingDropdownValueChange: EventEmitter<string | number>;
    /**
     * Phone change event
     */
    phoneChange: EventEmitter<string>;
    /**
     * Phone valid change event
     */
    validChange: EventEmitter<boolean>;
    /**
     * Leading icon click event
     */
    leadingIconClick: EventEmitter<MouseEvent>;
    value: string | number;
    isFocused: boolean;
    helpTooltipAlign: 'center' | 'start' | 'end';
    helpTooltipPlacement: 'above' | 'below';
    leadingDropdownOpen: boolean;
    trailingDropdownOpen: boolean;
    phoneText: string;
    countryList: {
        countryCode: string;
        countryName: string;
        countryCallingCode: string;
        flag: string;
    }[];
    customCountry: {
        countryCode: string;
        countryName: string;
        countryCallingCode: string;
        flag: string;
    };
    selectedCountry: {
        countryCode: string;
        countryName: string;
        countryCallingCode: string;
        flag: string;
    };
    isPhoneDropdownExpanded: boolean;
    private onChange;
    private onTouched;
    get hostClass(): boolean;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    writeValue(value: string | number): void;
    registerOnChange(fn: (value: string | number) => void): void;
    registerOnTouched(fn: () => void): void;
    setDisabledState(isDisabled: boolean): void;
    onInputChange(event: Event): void;
    private coerceValue;
    onInputFocus(event: FocusEvent): void;
    onInputBlur(event: FocusEvent): void;
    onKeydown(event: KeyboardEvent): void;
    onKeyup(event: KeyboardEvent): void;
    onLeadingDropdownChange(value: string | number): void;
    onTrailingDropdownChange(value: string | number): void;
    toggleLeadingDropdown(): void;
    toggleTrailingDropdown(): void;
    /**
     * Position the help tooltip so it never overflows the viewport. Horizontally:
     * anchored to the icon's right edge near the right border, to its left edge near
     * the left border, otherwise centered. Vertically: above by default, flipped
     * below when there isn't room above and there's more room below (e.g. an icon
     * near the top of the viewport). Computed from the icon rect synchronously
     * (before paint) so the tooltip appears in its final spot without a flicker.
     */
    updateHelpTooltipPlacement(event: Event): void;
    closeDropdowns(): void;
    get hasValue(): boolean;
    get showLabel(): boolean;
    get showHintText(): boolean;
    get displayHintText(): string;
    get characterCount(): string;
    get inputClasses(): string;
    getLeadingDropdownLabel(): string;
    getTrailingDropdownLabel(): string;
    focusInput(): void;
    /**
     * Drag-to-resize for the multiline textarea via the custom footer handle.
     * Native resize is disabled in CSS; this adjusts the textarea height while
     * the pointer is held, clamped to a minimum.
     */
    onResizeStart(event: PointerEvent): void;
    parsePhoneNumber(): void;
    onCountryChanged(country: any): void;
    onPhoneChanged(input?: HTMLInputElement): void;
    hidePhoneDropdown(): void;
    togglePhoneDropdown(): void;
    onPhoneInputChange(event: Event): void;
    onLeadingIconClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenduInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenduInputComponent, "zen-input", never, { "type": { "alias": "type"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "label": { "alias": "label"; "required": false; }; "hintText": { "alias": "hintText"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "helpIcon": { "alias": "helpIcon"; "required": false; }; "helpTooltip": { "alias": "helpTooltip"; "required": false; }; "destructive": { "alias": "destructive"; "required": false; }; "errorMessage": { "alias": "errorMessage"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "required": { "alias": "required"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "minLength": { "alias": "minLength"; "required": false; }; "pattern": { "alias": "pattern"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "name": { "alias": "name"; "required": false; }; "id": { "alias": "id"; "required": false; }; "leadingDropdownOptions": { "alias": "leadingDropdownOptions"; "required": false; }; "leadingDropdownValue": { "alias": "leadingDropdownValue"; "required": false; }; "leadingDropdownPlaceholder": { "alias": "leadingDropdownPlaceholder"; "required": false; }; "trailingDropdownOptions": { "alias": "trailingDropdownOptions"; "required": false; }; "trailingDropdownValue": { "alias": "trailingDropdownValue"; "required": false; }; "trailingDropdownPlaceholder": { "alias": "trailingDropdownPlaceholder"; "required": false; }; "leadingText": { "alias": "leadingText"; "required": false; }; "trailingText": { "alias": "trailingText"; "required": false; }; "multiline": { "alias": "multiline"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "size": { "alias": "size"; "required": false; }; "showCharacterCount": { "alias": "showCharacterCount"; "required": false; }; "phoneMaxLength": { "alias": "phoneMaxLength"; "required": false; }; "phone": { "alias": "phone"; "required": false; }; "width": { "alias": "width"; "required": false; }; }, { "valueChange": "valueChange"; "inputFocus": "inputFocus"; "inputBlur": "inputBlur"; "inputKeydown": "inputKeydown"; "inputKeyup": "inputKeyup"; "leadingDropdownChange": "leadingDropdownChange"; "leadingDropdownValueChange": "leadingDropdownValueChange"; "trailingDropdownChange": "trailingDropdownChange"; "trailingDropdownValueChange": "trailingDropdownValueChange"; "phoneChange": "phoneChange"; "validChange": "validChange"; "leadingIconClick": "leadingIconClick"; }, never, never, false, never>;
    static ngAcceptInputType_multiline: unknown;
    static ngAcceptInputType_rows: unknown;
    static ngAcceptInputType_resizable: unknown;
}

declare class ZenButtonComponent {
    variant: 'primary' | 'secondary-gray' | 'secondary' | 'tertiary-gray' | 'tertiary' | 'link-gray' | 'link';
    buttonType: 'button' | 'button-dot' | 'button-icon-leading' | 'button-icon-trailing' | 'button-icon-only';
    icon?: string;
    iconRotated: boolean;
    size: '2xl' | 'xl' | 'lg' | 'md' | 'sm';
    destructive: boolean;
    disabled: boolean;
    fullWidth: boolean;
    type: 'button' | 'submit' | 'reset';
    get isIconOnly(): boolean;
    get buttonClasses(): string;
    getIconName(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenButtonComponent, "zen-button", never, { "variant": { "alias": "variant"; "required": false; }; "buttonType": { "alias": "buttonType"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconRotated": { "alias": "iconRotated"; "required": false; }; "size": { "alias": "size"; "required": false; }; "destructive": { "alias": "destructive"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "type": { "alias": "type"; "required": false; }; }, {}, never, ["*"], false, never>;
}

interface DropdownMenuItem {
    label?: string;
    icon?: string;
    shortcut?: string;
    checked?: boolean;
    divider?: boolean;
    disabled?: boolean;
}
interface DropdownMenuHeader {
    name: string;
    email: string;
    avatarSrc?: string;
}
type DropdownTriggerType = 'list-header' | 'icon' | 'button' | 'avatar';
declare class ZenDropdownMenuComponent implements AfterViewInit, OnDestroy {
    private elementRef;
    triggerType: DropdownTriggerType;
    buttonText: string;
    avatarSrc?: string;
    items: DropdownMenuItem[];
    showCheckbox: boolean;
    showShortcut: boolean;
    showIcon: boolean;
    showCount: boolean;
    headerUser?: DropdownMenuHeader;
    showHeader: boolean;
    position: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'left' | 'right' | 'bottom' | '';
    offset: number;
    closeOnOutsideClick: boolean;
    scrollHandler: string;
    itemClick: EventEmitter<DropdownMenuItem>;
    itemCheck: EventEmitter<{
        item: DropdownMenuItem;
        checked: boolean;
    }>;
    openChange: EventEmitter<boolean>;
    onClose: EventEmitter<any>;
    dropdownElement: ElementRef<HTMLElement>;
    isOpen: boolean;
    dropdownVisible: boolean;
    private scrollSubscription;
    constructor(elementRef: ElementRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    toggleDropdown(): void;
    openDropdown(): void;
    closeDropdown(): void;
    updateDropdownPosition(): void;
    onDocumentClick(event: MouseEvent): void;
    handleMouseScroll(event: WheelEvent): void;
    onWindowKeyDown(event: KeyboardEvent): void;
    onWindowResize(): void;
    get showListHeader(): boolean;
    get showIconTrigger(): boolean;
    get showButton(): boolean;
    get showAvatar(): boolean;
    onItemClick(item: DropdownMenuItem, event?: MouseEvent): void;
    onCheckboxChange(item: DropdownMenuItem, checked: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenDropdownMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenDropdownMenuComponent, "zen-dropdown-menu", never, { "triggerType": { "alias": "triggerType"; "required": false; }; "buttonText": { "alias": "buttonText"; "required": false; }; "avatarSrc": { "alias": "avatarSrc"; "required": false; }; "items": { "alias": "items"; "required": false; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; "showShortcut": { "alias": "showShortcut"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; "showCount": { "alias": "showCount"; "required": false; }; "headerUser": { "alias": "headerUser"; "required": false; }; "showHeader": { "alias": "showHeader"; "required": false; }; "position": { "alias": "position"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "closeOnOutsideClick": { "alias": "closeOnOutsideClick"; "required": false; }; "scrollHandler": { "alias": "scrollHandler"; "required": false; }; }, { "itemClick": "itemClick"; "itemCheck": "itemCheck"; "openChange": "openChange"; "onClose": "onClose"; }, never, never, false, never>;
}

type ZenBadgeSize = 'sm' | 'md' | 'lg';
type ZenBadgeColor = 'gray' | 'primary' | 'error' | 'warning' | 'success' | 'blue-gray' | 'blue-light' | 'blue' | 'indigo' | 'purple' | 'pink' | 'rose' | 'orange';
type ZenBadgeIconDirection = 'left' | 'right';
type ZenBadgeGroupTheme = 'light' | 'medium' | 'dark';
type ZenBadgeGroupBadgePosition = 'leading' | 'trailing';
declare class ZenBadgeComponent {
    size: ZenBadgeSize;
    color: ZenBadgeColor;
    dot: boolean;
    removable: boolean;
    iconOnly: boolean;
    /** Icon name (resolved via zen-icon's iconBasePath) */
    icon: string;
    /** Direct icon src URL (use instead of name) */
    iconSrc: string;
    /** Icon placement direction */
    iconDirection: ZenBadgeIconDirection;
    /** Image src (country flag or avatar) — shown as a round image left of text */
    imgSrc: string;
    /** Badge group mode — renders as a pill with inner badge + message */
    group: boolean;
    /** Badge group: inner badge label text */
    badgeLabel: string;
    /** Badge group: badge position (leading = left, trailing = right) */
    badgePosition: ZenBadgeGroupBadgePosition;
    /** Badge group: theme variant */
    theme: ZenBadgeGroupTheme;
    /** Badge group: show arrow icon */
    showIcon: boolean;
    remove: EventEmitter<void>;
    clicked: EventEmitter<MouseEvent>;
    get hasIcon(): boolean;
    get hostClasses(): string;
    get groupClasses(): string;
    onClick(event: MouseEvent): void;
    onRemove(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenBadgeComponent, "zen-badge", never, { "size": { "alias": "size"; "required": false; }; "color": { "alias": "color"; "required": false; }; "dot": { "alias": "dot"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "iconOnly": { "alias": "iconOnly"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconSrc": { "alias": "iconSrc"; "required": false; }; "iconDirection": { "alias": "iconDirection"; "required": false; }; "imgSrc": { "alias": "imgSrc"; "required": false; }; "group": { "alias": "group"; "required": false; }; "badgeLabel": { "alias": "badgeLabel"; "required": false; }; "badgePosition": { "alias": "badgePosition"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "showIcon": { "alias": "showIcon"; "required": false; }; }, { "remove": "remove"; "clicked": "clicked"; }, never, ["*"], false, never>;
}

type ZenTooltipPosition = 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right';
type ZenTooltipTheme = 'dark' | 'light';
declare class ZenTooltipPopupComponent {
    text: string;
    supportingText: string;
    theme: ZenTooltipTheme;
    position: ZenTooltipPosition;
    get arrowPosition(): string;
    get hasSupportingText(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenTooltipPopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenTooltipPopupComponent, "zen-tooltip-popup", never, { "text": { "alias": "text"; "required": false; }; "supportingText": { "alias": "supportingText"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenTooltipDirective implements OnDestroy {
    private _overlay;
    private _elementRef;
    private _viewContainerRef;
    text: string;
    tooltipSupportingText: string;
    tooltipPosition: ZenTooltipPosition;
    tooltipTheme: ZenTooltipTheme;
    tooltipDisabled: boolean;
    tooltipDelay: number;
    private _overlayRef;
    private _tooltipRef;
    private _showTimeoutId;
    constructor(_overlay: Overlay, _elementRef: ElementRef, _viewContainerRef: ViewContainerRef);
    onMouseEnter(): void;
    onMouseLeave(): void;
    onFocus(): void;
    onBlur(): void;
    ngOnDestroy(): void;
    private _scheduleShow;
    private _show;
    private _hide;
    private _getPositionStrategy;
    private _getPositions;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ZenTooltipDirective, "[zenTooltip]", never, { "text": { "alias": "zenTooltip"; "required": false; }; "tooltipSupportingText": { "alias": "tooltipSupportingText"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipTheme": { "alias": "tooltipTheme"; "required": false; }; "tooltipDisabled": { "alias": "tooltipDisabled"; "required": false; }; "tooltipDelay": { "alias": "tooltipDelay"; "required": false; }; }, {}, never, never, false, never>;
}

type ZenEldStatusType = 'on-duty' | 'off-duty' | 'driving' | 'sleeper' | 'personal-conveyance' | 'yard-move';
declare class ZenEldStatusComponent {
    status: ZenEldStatusType;
    get hostClasses(): string;
    get abbreviation(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenEldStatusComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenEldStatusComponent, "zen-eld-status", never, { "status": { "alias": "status"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenNavSearchComponent {
    placeholder: string;
    value: string;
    valueChange: EventEmitter<string>;
    search: EventEmitter<string>;
    hovered: boolean;
    get hostClasses(): string;
    onInput(event: Event): void;
    onSearch(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenNavSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenNavSearchComponent, "zen-nav-search", never, { "placeholder": { "alias": "placeholder"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; "search": "search"; }, never, never, false, never>;
}

declare class ZenSubmoduleItemComponent {
    label: string;
    icon: string;
    current: boolean;
    activate: EventEmitter<void>;
    get hostClasses(): string;
    get iconColor(): string;
    onActivate(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenSubmoduleItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenSubmoduleItemComponent, "zen-submodule-item", never, { "label": { "alias": "label"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "current": { "alias": "current"; "required": false; }; }, { "activate": "activate"; }, never, never, false, never>;
}

type ZenSubpageItemType = 'vehicle' | 'driver';
type ZenSubpageItemState = 'default' | 'hover' | 'focused';
declare class ZenSubpageItemComponent {
    type: ZenSubpageItemType;
    state: ZenSubpageItemState;
    label: string;
    eldStatus: ZenEldStatusType;
    activate: EventEmitter<void>;
    private _hovered;
    get hostClasses(): string;
    get typeIcon(): string;
    get iconColor(): string;
    onActivate(): void;
    onMouseEnter(): void;
    onMouseLeave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenSubpageItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenSubpageItemComponent, "zen-subpage-item", never, { "type": { "alias": "type"; "required": false; }; "state": { "alias": "state"; "required": false; }; "label": { "alias": "label"; "required": false; }; "eldStatus": { "alias": "eldStatus"; "required": false; }; }, { "activate": "activate"; }, never, never, false, never>;
}

type ZenModulePopupModule = 'fleet' | 'safety' | 'operations' | 'reports' | 'bus' | 'fuel' | 'maintain' | 'efficiency' | 'inventory' | 'more';
interface ZenModulePopupItem {
    label: string;
    route?: string;
    tag?: unknown;
}
declare class ZenModulePopupComponent {
    private _elementRef;
    module: ZenModulePopupModule;
    items: ZenModulePopupItem[];
    isOpen: boolean;
    itemClick: EventEmitter<ZenModulePopupItem>;
    close: EventEmitter<void>;
    constructor(_elementRef: ElementRef);
    get moduleLabel(): string;
    get moduleIcon(): string;
    get hostClasses(): string;
    onItemClick(item: ZenModulePopupItem): void;
    onDocumentClick(event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenModulePopupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenModulePopupComponent, "zen-module-popup", never, { "module": { "alias": "module"; "required": false; }; "items": { "alias": "items"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; }, { "itemClick": "itemClick"; "close": "close"; }, never, never, false, never>;
}

type ZenChartStyle = 'line' | 'bar';
type ZenChartLegend = 'false' | 'top' | 'right';
interface ZenChartDataset {
    label: string;
    data: number[];
    color?: string;
}

declare class ZenChartComponent implements OnChanges, AfterViewInit {
    chartStyle: ZenChartStyle;
    legend: ZenChartLegend;
    axisLabels: boolean;
    labels: string[];
    datasets: ZenChartDataset[];
    xAxisLabel: string;
    yAxisLabel: string;
    stacked: boolean;
    colors: string[];
    breakpoint: 'desktop' | 'mobile';
    pointClick: EventEmitter<{
        datasetIndex: number;
        index: number;
        value: number;
    }>;
    chart?: BaseChartDirective;
    chartData: ChartData;
    chartOptions: ChartConfiguration['options'];
    private initialized;
    private get defaultPalette();
    get hostClasses(): string;
    getColor(index: number): string;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onChartClick(event: any): void;
    private buildChart;
    private applyGradients;
    private hexToRgba;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenChartComponent, "zen-chart", never, { "chartStyle": { "alias": "chartStyle"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "axisLabels": { "alias": "axisLabels"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "datasets": { "alias": "datasets"; "required": false; }; "xAxisLabel": { "alias": "xAxisLabel"; "required": false; }; "yAxisLabel": { "alias": "yAxisLabel"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; }, { "pointClick": "pointClick"; }, never, never, false, never>;
}

type ZenProgressStepsType = 'icons-centered' | 'minimal-icons' | 'minimal-icons-connected' | 'text-line' | 'icons-text';
type ZenProgressStepsSize = 'sm' | 'md' | 'lg';
type ZenProgressStepsTheme = 'light' | 'mid' | 'dark';
type ZenStepStatus = 'complete' | 'current' | 'incomplete';
type ZenStepBaseType = 'top' | 'icon-only' | 'text-line' | 'icon-left';
interface ZenStep {
    title?: string;
    description?: string;
}

declare class ZenProgressStepsComponent {
    type: ZenProgressStepsType;
    size: ZenProgressStepsSize;
    theme: ZenProgressStepsTheme;
    steps: ZenStep[];
    currentStep: number;
    showText: boolean;
    connector: boolean;
    get hostClasses(): string;
    getStepStatus(index: number): ZenStepStatus;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenProgressStepsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenProgressStepsComponent, "zen-progress-steps", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "steps": { "alias": "steps"; "required": false; }; "currentStep": { "alias": "currentStep"; "required": false; }; "showText": { "alias": "showText"; "required": false; }; "connector": { "alias": "connector"; "required": false; }; }, {}, never, never, false, never>;
}

declare class ZenStepBaseComponent {
    /** Layout type of the step */
    type: ZenStepBaseType;
    /** Size variant */
    size: ZenProgressStepsSize;
    /** Theme variant */
    theme: ZenProgressStepsTheme;
    /** Status of this step */
    status: ZenStepStatus;
    /** Step title */
    title: string;
    /** Step description / supporting text */
    description: string;
    /** Whether to show the vertical connector (icon-left type) */
    showConnector: boolean;
    get hostClasses(): string;
    get dotSize(): number;
    get checkSize(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenStepBaseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenStepBaseComponent, "zen-step-base", never, { "type": { "alias": "type"; "required": false; }; "size": { "alias": "size"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "status": { "alias": "status"; "required": false; }; "title": { "alias": "title"; "required": false; }; "description": { "alias": "description"; "required": false; }; "showConnector": { "alias": "showConnector"; "required": false; }; }, {}, never, never, false, never>;
}

type ZenSnackbarType = 'info' | 'neutral' | 'success' | 'warn' | 'error';
/**
 * Presentational card rendered by {@link ZenNotifyService} through a CDK overlay.
 * It draws the status icon, the message and an optional dismiss button, styled
 * per the ZenduONE design system (Untitled UI "Alert").
 */
declare class ZenSnackbarComponent {
    message: string;
    type: ZenSnackbarType;
    hasDismiss: boolean;
    /** Emitted when the user clicks the dismiss button. */
    dismiss: EventEmitter<void>;
    onDismiss(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<ZenSnackbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ZenSnackbarComponent, "zen-snackbar", never, { "message": { "alias": "message"; "required": false; }; "type": { "alias": "type"; "required": false; }; "hasDismiss": { "alias": "hasDismiss"; "required": false; }; }, { "dismiss": "dismiss"; }, never, never, false, never>;
}

declare class NgZenduitModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<NgZenduitModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<NgZenduitModule, [typeof ZenduCheckboxComponent, typeof ZenduToggleComponent, typeof ZenduToggleSlideComponent, typeof ZenduSearchBoxComponent, typeof ZenduSelectComponent, typeof ZenduSelectOptionDirective, typeof ZenduSelectValueDirective, typeof ZenduDatepickerComponent, typeof ZenduFilterComponent, typeof ZenduGroupsComponent, typeof ZenduPaginationBarComponent, typeof ZenduColumnConfigurationComponent, typeof ZenduSortHeaderComponent, typeof ZenduPhoneInputComponent, typeof ZenduColorPickerComponent, typeof ZenduRadioButtonComponent, typeof ZenduIconComponent, typeof ZenduCardBlockComponent, typeof ZenduMapPreviewComponent, typeof ZenduSpinner, typeof ZenduDocScanner, typeof ZenduMapComponent, typeof ZenduFileUpload, typeof ZenduProgress, typeof ZenduLocationSearch, typeof ZenLiveViewPlayerComponent, typeof ZenHTML5VideoPlayerComponent, typeof ZenFlvPlayerComponent, typeof ZenHlsPlayerComponent, typeof ZenSnapshotPlayerComponent, typeof ZenWebRTCPlayerComponent, typeof ZenduSelectButtonDirective, typeof ZenduTimepickerComponent, typeof ZenduDatePickerDropdownComponent, typeof ZenduFileUploaderComponent, typeof ZenduAvatarComponent, typeof ZenduAvatarGroupComponent, typeof ZenduAvatarLabelGroupComponent, typeof ZenduAvatarProfilePhotoComponent, typeof ZenduSliderComponent, typeof ZenduInputComponent, typeof ZenButtonComponent, typeof ZenDropdownMenuComponent, typeof ZenBadgeComponent, typeof ZenTooltipDirective, typeof ZenTooltipPopupComponent, typeof ZenEldStatusComponent, typeof ZenNavSearchComponent, typeof ZenSubmoduleItemComponent, typeof ZenSubpageItemComponent, typeof ZenModulePopupComponent, typeof ZenChartComponent, typeof ZenProgressStepsComponent, typeof ZenStepBaseComponent, typeof ZenSnackbarComponent], [typeof i56.CommonModule, typeof i57.FormsModule, typeof i58.DragDropModule, typeof i59.SignaturePadComponent, typeof i57.ReactiveFormsModule, typeof i60.OverlayModule, typeof i61.BaseChartDirective, typeof i62.TranslateModule], [typeof ZenduCheckboxComponent, typeof ZenduToggleComponent, typeof ZenduToggleSlideComponent, typeof ZenduSearchBoxComponent, typeof ZenduSelectComponent, typeof ZenduSelectOptionDirective, typeof ZenduSelectValueDirective, typeof ZenduDatepickerComponent, typeof ZenduFilterComponent, typeof ZenduGroupsComponent, typeof ZenduPaginationBarComponent, typeof ZenduColumnConfigurationComponent, typeof ZenduSortHeaderComponent, typeof ZenduPhoneInputComponent, typeof ZenduColorPickerComponent, typeof ZenduRadioButtonComponent, typeof ZenduIconComponent, typeof ZenduCardBlockComponent, typeof ZenduMapPreviewComponent, typeof ZenduSpinner, typeof ZenduDocScanner, typeof ZenduMapComponent, typeof ZenduFileUpload, typeof ZenduProgress, typeof ZenduLocationSearch, typeof ZenLiveViewPlayerComponent, typeof ZenduSelectButtonDirective, typeof ZenduTimepickerComponent, typeof ZenduDatePickerDropdownComponent, typeof ZenduFileUploaderComponent, typeof ZenduAvatarComponent, typeof ZenduAvatarGroupComponent, typeof ZenduAvatarLabelGroupComponent, typeof ZenduAvatarProfilePhotoComponent, typeof ZenduSliderComponent, typeof ZenduInputComponent, typeof ZenButtonComponent, typeof ZenDropdownMenuComponent, typeof ZenBadgeComponent, typeof ZenTooltipDirective, typeof ZenTooltipPopupComponent, typeof ZenEldStatusComponent, typeof ZenNavSearchComponent, typeof ZenSubmoduleItemComponent, typeof ZenSubpageItemComponent, typeof ZenModulePopupComponent, typeof ZenChartComponent, typeof ZenProgressStepsComponent, typeof ZenStepBaseComponent, typeof ZenSnackbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<NgZenduitModule>;
}

export { DATEPICKER_POSITION, NgZenduitModule, ZEN_DATE_PICKER_DEFAULT_PRESETS, ZEN_ICON_CONFIG, ZenBadgeComponent, ZenButtonComponent, ZenChartComponent, ZenDropdownMenuComponent, ZenEldStatusComponent, ZenLiveViewPlayerComponent, ZenModulePopupComponent, ZenNavSearchComponent, ZenNotifyService, ZenProgressStepsComponent, ZenSnackbarComponent, ZenStepBaseComponent, ZenSubmoduleItemComponent, ZenSubpageItemComponent, ZenTooltipDirective, ZenTooltipPopupComponent, ZenduAvatarComponent, ZenduAvatarGroupComponent, ZenduAvatarLabelGroupComponent, ZenduAvatarProfilePhotoComponent, ZenduCardBlockComponent, ZenduCheckboxComponent, ZenduColorPickerComponent, ZenduColumnConfigurationComponent, ZenduDatePickerDropdownComponent, ZenduDatepickerComponent, ZenduDocScanner, ZenduFileUpload, ZenduFileUploaderComponent, ZenduFilterComponent, ZenduGroupsComponent, ZenduIconComponent, ZenduInputComponent, ZenduLocationSearch, ZenduMapComponent, ZenduMapPreviewComponent, ZenduOverlayService, ZenduPaginationBarComponent, ZenduPhoneInputComponent, ZenduProgress, ZenduRadioButtonComponent, ZenduSearchBoxComponent, ZenduSelectButtonDirective, ZenduSelectComponent, ZenduSelectOptionDirective, ZenduSelectValueDirective, ZenduSliderComponent, ZenduSortHeaderComponent, ZenduSpinner, ZenduTimepickerComponent, ZenduToggleComponent, ZenduToggleSlideComponent };
export type { AddOptionEvent, Cancellation, ColumnState, DataSource, DatePickerDropdownType, DatePickerHint, DatePickerMarker, DatePickerPreset, DateRangeValue, DropdownMenuHeader, DropdownMenuItem, DropdownOption, DropdownTriggerType, FileUploadItem, FileUploaderProgressType, FiltersConfig, FiltersConfigItem, LazyLoaderFunction, LazyLoaderResult, LazyLoaderSearch, LocationAddress, MultiSelectItem, NumberRange, RemoveOptionEvent, SelectOption, TimePickerMode, TimePickerValue, ZenBadgeColor, ZenBadgeGroupBadgePosition, ZenBadgeGroupTheme, ZenBadgeIconDirection, ZenBadgeSize, ZenChartDataset, ZenChartLegend, ZenChartStyle, ZenConnectedPanelConfig, ZenConnectedPanelRef, ZenDevice, ZenEldStatusType, ZenIconColor, ZenIconConfig, ZenIconSize, ZenIconTheme, ZenLiveViewPlayerType, ZenLogRecord, ZenMapTheme, ZenModulePopupItem, ZenModulePopupModule, ZenPanelCloseReason, ZenProgressStepsSize, ZenProgressStepsTheme, ZenProgressStepsType, ZenSnackbarType, ZenStep, ZenStepBaseType, ZenStepStatus, ZenSubpageItemState, ZenSubpageItemType, ZenTooltipPosition, ZenTooltipTheme, ZenTrip, ZenduAvatarGroupSize, ZenduAvatarLabelGroupSize, ZenduAvatarProfilePhotoSize, ZenduAvatarSize, ZenduAvatarStatusIcon, ZenduSliderLabel };