import * as i0 from '@angular/core';
import { NgZone, AfterViewInit, ElementRef, AfterViewChecked, OnDestroy, QueryList, EventEmitter, OnInit, ChangeDetectorRef, ComponentRef, ApplicationRef, ComponentFactoryResolver, Injector, ViewContainerRef, Type, PipeTransform, OnChanges, SimpleChanges, AfterContentInit } from '@angular/core';
import { ControlValueAccessor, NgControl } from '@angular/forms';
import { Observable, Subscription } from 'rxjs';
import { Router } from '@angular/router';

declare class SohoAboutModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAboutModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoAboutModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoAboutModule>;
}

/**
 * Wrapper for the jQuery about control.
 */
declare class SohoAboutRef {
    private ngZone;
    private eventGuard;
    /** Selector referencing the about-dialog after it has been moved to the dialog container. */
    private jQueryElement?;
    /** Soho Control Api */
    private _about?;
    /** Dialog placeholder, defaults to $('body')*/
    private _placeholder;
    /**
     * Cached options.
     */
    private _options;
    /**
     * Sets the whole options block for this modal dialog.
     *
     * @param options - the options to set.
     */
    options(options?: SohoAboutOptions): SohoAboutRef;
    /**
     * Sets the appName on the about dialog
     *
     * @param appName - the application name
     */
    appName(appName: string): SohoAboutRef;
    /**
     * Sets the additional 'content' that the about dialog displays.
     *
     * @param content - the additional text content
     */
    content(content: string): SohoAboutRef;
    /**
     * Sets the copyrightYear of the about dialog.
     */
    copyrightYear(copyrightYear: string): SohoAboutRef;
    /**
     * Sets Whether or not to show the deviceSpecs
     *
     * @param deviceSpecs - if true; the about dialog will show device info
     */
    deviceSpecs(deviceSpecs: boolean): SohoAboutRef;
    /**
     * Sets The Additional productName
     *
     * @param productName - the product name
     */
    productName(productName: string): SohoAboutRef;
    /**
     * Sets The Additional productName
     *
     * @param productName - the product name
     */
    useDefaultCopyright(useDefaultCopyright: boolean): SohoAboutRef;
    /**
     * Sets about dialog version
     *
     * @param version - the semantic version no fx 4.0.1
     */
    version(version: string): SohoAboutRef;
    /**
     * Add extra attributes like id's to the component
     *
     * @param attributes - the array or object of attributes to add
     */
    attributes(attributes: Array<Object> | Object): SohoAboutRef;
    /**
     * Constructor.
     *
     * @param placeholder for the about dialog; defaults to the body.
     */
    constructor(ngZone: NgZone);
    /**
     * Displays the about dialog.
     *
     * @return the dialog ref.
     */
    open(): SohoAboutRef;
    /**
     * Closes the about dialog, if open.
     *
     * @param dialogResult - optional result - held for the caller.
     */
    close(): SohoAboutRef;
    /**
     * Registers a before open guard.
     *
     * @param eventFn - the function to call before openning the dialog.
     */
    beforeOpen(eventFn: (dialogRef?: SohoAboutRef) => boolean): SohoAboutRef;
    /**
     * Registers a closed guard.
     *
     * @param eventFn - the function to call before openning the dialog.
     */
    closed(eventFn: (dialogRef?: SohoAboutRef) => boolean): SohoAboutRef;
    /**
     * Registers a after close guard.
     *
     * @param eventFn - the function to call before openning the dialog.
     */
    afterClose(eventFn: (dialogRef?: SohoAboutRef) => boolean): SohoAboutRef;
    /**
     * Handles the 'beforeOpen' event, fired before the modal dialog
     * has been opened.
     *
     * @param event - full event object.
     *
     * @return true if the dialog can be opened; otherwise false if veoted.
     */
    private onBeforeOpen;
    /**
     * Handles the 'closed' event, fired before the modal dialog
     * has been opened.
     *
     * @param event - full event object.
     *
     * @return true if the dialog can be opened; otherwise false if veoted.
     */
    private onClose;
    /**
     * Handles the 'afterClose' event, fired before the modal dialog
     * has been opened.
     *
     * @param event - full event object.
     *
     * @return true if the dialog can be opened; otherwise false if veoted.
     */
    private onAfterClose;
}
/**
 * Event Handlers.
 */
interface SohoAboutDialogEventGuard {
    /**
     * Invoked before a modal is opened.
     *
     * @return false to veto the open action; otherwise true.
     */
    beforeOpen?(dialogRef: SohoAboutRef): boolean;
    /**
     * Invoked when closing a modal.
     *
     * @return false to veto the open action; otherwise true.
     */
    closed?(dialogRef: SohoAboutRef): boolean;
    /**
     * Invoked after the modal is closed.
     *
     * @return false to veto the open action; otherwise true.
     */
    afterClose?(dialogRef: SohoAboutRef): boolean;
}

/**
 * This service is used to create about dialogs.
 */
declare class SohoAboutService {
    private readonly ngZone;
    /**
     * Constructor.
     */
    constructor(ngZone: NgZone);
    /**
     * Creates a about defined by the given info, returning a reference to the
     * associated about dialog that can be interacted with.
     *
     * The about dialog won't be open until open is called on the returned instance,
     * see the about ref api for further methods.
     *
     * @parent options - a compete set of options; can be null.
     *
     * @return the about reference.
     */
    about(options?: SohoAboutOptions): SohoAboutRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAboutService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoAboutService>;
}

declare class SohoAccordionHeaderComponent implements AfterViewInit {
    elementRef: ElementRef;
    /**
     * Reference to the jQuery control - this is public so
     * it can be used in the api on the accordion control.
     */
    jQueryElement: JQuery;
    isDisabled: boolean;
    isBlockDisplay: string;
    isAccordionHeader: boolean;
    isExpanded: boolean;
    moduleNavItem: boolean;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching the component's selector.
     */
    constructor(elementRef: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAccordionHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoAccordionHeaderComponent, "soho-accordion-header", never, { "isExpanded": { "alias": "isExpanded"; "required": false; }; "moduleNavItem": { "alias": "moduleNavItem"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoAccordionPaneComponent {
    get isAccordionPane(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAccordionPaneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoAccordionPaneComponent, "soho-accordion-pane", never, {}, {}, never, ["*"], true, never>;
}

/**
 * Angular Wrapper for the Soho Accordion control.
 *
 * This component searches for an element, annotated with the `soho-accordion` attribute,
 * and then matches this component to it.
 * <br>
 * The characteristics of the component can be controlled using the set of inputs.
 *
 * The Accordion is a grouped set of collapsible panels used to navigate sections of
 * related content. Each panel consists of two levels: the top level identifies the
 * category or section header, and the second level provides the associated options.
 */
declare class SohoAccordionComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    headers: QueryList<SohoAccordionHeaderComponent>;
    panes: QueryList<SohoAccordionPaneComponent>;
    options: SohoAccordionOptions;
    /** Reference to the jQuery selector. */
    private jQueryElement;
    /**
     * References to the Soho control api.
     */
    private accordion;
    /**
     * Used to call updated from the afterViewChecked lifecycle event.
     */
    private updateRequired?;
    beforeexpandEvent: EventEmitter<any>;
    beforecollapseEvent: EventEmitter<any>;
    beforeselectEvent: EventEmitter<any>;
    selectedEvent: EventEmitter<any>;
    followlinkEvent: EventEmitter<any>;
    expandEvent: EventEmitter<any>;
    afterexpandEvent: EventEmitter<any>;
    collapseEvent: EventEmitter<any>;
    aftercollapseEvent: EventEmitter<any>;
    /**
     * If an Accordion pane is open, and that pane contains sub-headers, only one
     * of the pane's sub-headers can be open at a time.
     *
     * Defaults to true.
     *
     * If set to true, allows only one pane of the accordion to be open at a time.
     */
    set allowOnePane(allowOnePane: boolean | undefined);
    get allowOnePane(): boolean | undefined;
    /**
     * Displays a "Chevron" icon that sits off to the right-most side of a top-level accordion header.
     * Used in place of an Expander (+/-) if enabled.
     *
     *
     */
    set displayChevron(displayChevron: boolean | undefined);
    get displayChevron(): boolean | undefined;
    /**
     * Changes the iconography used in accordion header expander buttons.
     */
    set expanderDisplay(expanderDisplay: SohoAccordionExpanderType | undefined);
    get expanderDisplay(): SohoAccordionExpanderType | undefined;
    /**
     * Can be set to false if routing is externally handled, otherwise
     * links are handled normally.
     */
    set rerouteOnLinkClick(rerouteOnLinkClick: boolean | undefined);
    get rerouteOnLinkClick(): boolean | undefined;
    /**
     * Add a alert badge to the accordion header (used for App menu)
     */
    set notificationBadge(notificationBadge: boolean | undefined);
    get notificationBadge(): boolean | undefined;
    /**
     * A callback function that when implemented provided a call back for "ajax loading" of tab contents on open.
     */
    set source(source: Function | undefined);
    get source(): Function | undefined;
    /**
     * Display accordion with panels
     */
    set hasPanels(hasPanels: boolean | undefined);
    get hasPanels(): boolean | undefined;
    /**
     * Set the color scheme to inverse
     */
    set inverse(inverse: boolean | undefined);
    get inverse(): boolean | undefined;
    /**
     * Set the color scheme to alternate
     */
    set alternate(bool: boolean | undefined);
    get alternate(): boolean | undefined;
    /**
     * Enables tooltips for longer text that is handled with ellipsis
     */
    set enableTooltips(enableTooltips: boolean | undefined);
    get enableTooltips(): boolean | undefined;
    hasSubheaderSeparators?: boolean;
    /** Enables Module Nav variant */
    moduleNav?: boolean;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching the component's selector.
     * @param ngZone - zone access.
     */
    constructor(element: ElementRef, ngZone: NgZone);
    /**
     * Makes provided accordion headers appear "selected"
     */
    select(header: SohoAccordionHeaderComponent | string): void;
    /**
     * Makes provided accordion headers appear "deselected"
     */
    deselect(header: SohoAccordionHeaderComponent | string): void;
    /**
     * Makes all accordion headers appear "deselected"
     */
    deselectAll(): void;
    /**
     * Get's the nth header from the accordion.
     *
     * @todo - how best to access the headers?
     *
     * @param index - the index of the accordion header.
     * @return the header at the given index.
     */
    getHeader(index: number): SohoAccordionHeaderComponent | undefined;
    /**
     * Expand the given Panel on the Accordion.
     *
     * @param header &nbsp;-&nbsp; the header component
     */
    expand(header: SohoAccordionHeaderComponent | string): void;
    /**
     * Collapse the given Panel on the Accordion.
     *
     * @param header &nbsp;-&nbsp; the jquery header element
     */
    collapse(header: SohoAccordionHeaderComponent | string): void;
    /**
     * Expands all accordion headers, if possible.
     */
    expandAll(): void;
    /**
     * Collapses all the expanded panels.
     *
     *
     */
    collapseAll(): void;
    /**
     * Disables the control.
     */
    disable(): void;
    /**
     * Enables the control.
     */
    enable(): void;
    /**
     * Returns true if the given header is currently disabled or the whole accordion
     * is disabled; otherwise false.
     *
     * @param header the accordion header panel to check.
     */
    isDisabled(header: SohoAccordionHeaderComponent): boolean;
    /**
     * Returns true if the given header is currently expanded; otherwise
     * false.
     *
     * @param header the accordion header panel to check.
     */
    isExpanded(header: SohoAccordionHeaderComponent): boolean;
    /**
     * Toggle the given Panel on the Accordion between expanded and collapsed
     *
     * @param header &nbsp;-&nbsp; the jquery header element
     */
    toggle(header: SohoAccordionHeaderComponent): void;
    /**
     * Call to notify the accordion about any dom changes
     */
    updated(headers?: JQuery[], settings?: SohoAccordionOptions): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    private markForUpdate;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAccordionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoAccordionComponent, "soho-accordion, [soho-accordion]", never, { "allowOnePane": { "alias": "allowOnePane"; "required": false; }; "displayChevron": { "alias": "displayChevron"; "required": false; }; "expanderDisplay": { "alias": "expanderDisplay"; "required": false; }; "rerouteOnLinkClick": { "alias": "rerouteOnLinkClick"; "required": false; }; "notificationBadge": { "alias": "notificationBadge"; "required": false; }; "source": { "alias": "source"; "required": false; }; "hasPanels": { "alias": "hasPanels"; "required": false; }; "inverse": { "alias": "inverse"; "required": false; }; "alternate": { "alias": "alternate"; "required": false; }; "enableTooltips": { "alias": "enableTooltips"; "required": false; }; "hasSubheaderSeparators": { "alias": "hasSubheaderSeparators"; "required": false; }; "moduleNav": { "alias": "moduleNav"; "required": false; }; }, { "beforeexpandEvent": "beforeexpand"; "beforecollapseEvent": "beforecollapse"; "beforeselectEvent": "beforeselect"; "selectedEvent": "selected"; "followlinkEvent": "followlink"; "expandEvent": "expand"; "afterexpandEvent": "afterexpand"; "collapseEvent": "collapse"; "aftercollapseEvent": "aftercollapse"; }, ["headers", "panes"], ["*"], true, never>;
}

declare class SohoAccordionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAccordionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoAccordionModule, never, [typeof SohoAccordionComponent, typeof SohoAccordionHeaderComponent, typeof SohoAccordionPaneComponent], [typeof SohoAccordionComponent, typeof SohoAccordionHeaderComponent, typeof SohoAccordionPaneComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoAccordionModule>;
}

declare class SohoActionsheetComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    display: string;
    /**
     * Constructor
     *
     * @param elementRef - the element matching the component's selector.
     * @param ngZone - the angular zone for this component.
     */
    constructor(element: ElementRef, ngZone: NgZone);
    private _options;
    private actionsheet?;
    private jQueryElement;
    set actions(actions: Array<SohoActionsheetActions> | undefined);
    get actions(): Array<SohoActionsheetActions> | undefined;
    set showCancelButton(showCancelButton: boolean | undefined);
    get showCancelButton(): boolean | undefined;
    set autoFocus(autoFocus: boolean | undefined);
    get autoFocus(): boolean | undefined;
    set breakpoint(breakpoint: string | undefined);
    get breakpoint(): string | undefined;
    set displayAsActionSheet(displayAsActionSheet: SohoActionsheetDisplay | undefined);
    get displayAsActionSheet(): SohoActionsheetDisplay | undefined;
    set overlayOpacity(overlayOpacity: number | undefined);
    get overlayOpacity(): number | undefined;
    set onSelect(onSelect: Function | undefined);
    get onSelect(): Function | undefined;
    set onCancel(onCancel: Function | undefined);
    get onCancel(): Function | undefined;
    set tray(tray: boolean | undefined);
    get tray(): boolean | undefined;
    set trayOpts(trayOpts: SohoActionsheetTrayOptions | undefined);
    get trayOpts(): SohoActionsheetTrayOptions | undefined;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    ngAfterViewInit(): void;
    /** Tears down and removes any added markup and events. */
    ngOnDestroy(): void;
    /**
     * Triggers a UI Resync.
     */
    updated(settings?: SohoActionsheetOptions): void;
    /**
     * Tears down and removes any added markup and events.
     */
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoActionsheetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoActionsheetComponent, "div[soho-actionsheet]", never, { "actions": { "alias": "actions"; "required": false; }; "showCancelButton": { "alias": "showCancelButton"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "displayAsActionSheet": { "alias": "displayAsActionSheet"; "required": false; }; "overlayOpacity": { "alias": "overlayOpacity"; "required": false; }; "onSelect": { "alias": "onSelect"; "required": false; }; "onCancel": { "alias": "onCancel"; "required": false; }; "tray": { "alias": "tray"; "required": false; }; "trayOpts": { "alias": "trayOpts"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoActionsheetModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoActionsheetModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoActionsheetModule, never, [typeof SohoActionsheetComponent], [typeof SohoActionsheetComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoActionsheetModule>;
}

/**
 * Angular Wrapper for the SohoAlert Directive.
 *
 */
declare class SohoAlertDirective implements AfterViewInit {
    elementRef: ElementRef;
    private ngZone;
    private _options;
    private jQueryElement?;
    /** Set or remove the message. */
    set message(message: string);
    set id(id: string | undefined);
    set type(type: SohoAlertType);
    /** Set message with or without control color */
    set isAlert(isAlert: boolean | undefined);
    set truncated(truncated: boolean);
    /** Set message whether to trigger events */
    set triggerEvents(triggerEvents: boolean | undefined);
    /** Set message with or without custom icon */
    set icon(icon: string | undefined);
    /**
     * Returns the data object data-errormessage
     *
     * @deprecated use getMessage() instead
     * @return error
     */
    get errorMessage(): string;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    /**
     * After the control has been initialised and the view is ready,
     * get the SoHoXi controls to activate any alerts.
     */
    ngAfterViewInit(): void;
    /**
     * Adds an inline error message
     *
     * @deprecated use addInlineMessage() instead
     * @param message the error message to add.
     */
    addInlineError(message: string): void;
    /**
     * Adds an inline message of the type specified
     *
     * @param message the message to add.
     * @param type optional - 'error' (default)
     * @param isAlert optional - false (default)
     * @param triggerEvents optional - true (default)
     * @param icon optional - icon for the message
     * @param id optional - id for the message
     */
    addInlineMessage(message: string, type?: SohoAlertType, isAlert?: boolean, triggerEvents?: boolean, icon?: string, id?: string): void;
    /**
     * Gets the message of the type specified
     *
     * @param type optional - 'error' default
     * @return returns the message for the given type.
     */
    getMessage(type?: SohoAlertType): string;
    /**
     * Removes the error message
     *
     * @deprecated use removeMessage() instead
     */
    removeError(): void;
    /**
     * Removes the message of the type specified
     *
     * @param type optional - 'error' (default)
     * @param triggerEvents optional - true (default) triggers events
     */
    removeMessage(type?: SohoAlertType, triggerEvents?: boolean | undefined): void;
    /**
     * Removes the message for all types
     *
     * @param triggerEvents optional - true (default) triggers events
     */
    removeAllMessages(triggerEvents?: boolean): void;
    /**
     * Scrolls the element into the visible area of the browser window
     *
     * @param alignToTop optional - true (default) element will be aligned to the top of the visible area of the scrollable ancestor
     */
    scrollIntoView(alignToTop?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAlertDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoAlertDirective, "[soho-alert]", ["soho-alert"], { "message": { "alias": "message"; "required": false; }; "id": { "alias": "id"; "required": false; }; "type": { "alias": "type"; "required": false; }; "isAlert": { "alias": "isAlert"; "required": false; }; "truncated": { "alias": "truncated"; "required": false; }; "triggerEvents": { "alias": "triggerEvents"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoAlertModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAlertModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoAlertModule, never, [typeof SohoAlertDirective], [typeof SohoAlertDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoAlertModule>;
}

/**
 * Angular Wrapper for the Soho Application Menu Component.
 *
 * This component searches for a nav element with the attribute
 * 'soho-applcation-menu' in the parent's DOM tree, initialising those found with
 * the Soho application menu control.
 */
declare class SohoApplicationMenuComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    /** Breakpoint. */
    breakpoint?: SohoApplicationMenuBreakPoint;
    /** Sets Open on resize */
    set openOnLarge(openOnLarge: boolean | undefined);
    get openOnLarge(): boolean | undefined;
    /** Allows the menu to become closed after an actionable header has been selected */
    set dismissOnClickMobile(dismissOnClickMobile: boolean | undefined);
    get dismissOnClickMobile(): boolean | undefined;
    /** A list of jQuery elements which trigger the openning and closing application menu. */
    set triggers(triggers: string[]);
    /**
     * Is the application menu filterable?
     */
    filterable?: boolean;
    /**
     * Is the application menu resizable?
     */
    set resizable(resizable: boolean | undefined);
    get resizable(): boolean | undefined;
    /**
     * Resizeable Save Position Settings
     */
    set savePosition(savePosition: boolean | undefined);
    get savePosition(): boolean | undefined;
    /**
     *
     * @param expandSwitcher
     * Menu switcher expand setting to provide callback
     */
    set onExpandSwitcher(expandSwitcher: SohoApplicationMenuExpandSwitcherFunction);
    /**
     *
     * @param collapseSwitcher
     * Menu switcher collapse setting to provide callback
     */
    set onCollapseSwitcher(collapseSwitcher: SohoApplicationMenuCollapseSwitcherFunction);
    appMenu: boolean;
    isPersonalizable: boolean;
    /**
     * This will let the Soho controls bind the application menu trigger naturally
     */
    get menuId(): string;
    /** Reference to the jQuery element. */
    private jQueryElement?;
    /** Reference to the annotated SoHoXi control */
    private applicationmenu?;
    /** List of jQuery triggers. */
    private _triggers;
    /** Open on resize */
    private _openOnLarge?;
    /** Dismiss the menu when an item is clicked in the mobile breakpoints */
    private _dismissOnClickMobile?;
    private _resizable?;
    private _savePosition?;
    /** Menu switcher expand callback  */
    private _onExpandSwitcher?;
    /** Menu switcher collapse callback  */
    private _onCollapseSwitcher?;
    /**
     * This event is fired when the visibility of the application menu is changed,
     * is it also called when the item is changed programmatically.
     *
     * @deprecated use accordionExpand and accordionCollapse events instead
     */
    visibility: EventEmitter<any>;
    /**
     * This event is fired when a menu accordion is expamded
     * The event include the anchor element.
     */
    accordionExpand: EventEmitter<any>;
    /**
     * This event is fired when a menu accordion is collapsed
     */
    accordionCollapse: EventEmitter<boolean>;
    /** This event is fired when the visibility of the application menu is changed */
    menuVisibility: EventEmitter<boolean>;
    /** This event is fired when the application menu is filtered. */
    filtered: EventEmitter<any[]>;
    /** flag the need to update the soho/ep control in ngAfterViewChecked. */
    private updateRequired;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    /**
     * Close the menu.
     */
    closeMenu(): void;
    /** Open the menu. */
    openMenu(noFocus?: boolean, userOpened?: boolean, openedByClass?: boolean): void;
    /**
     * Returns true if the menu is open, otherwise false.
     */
    isOpen(): boolean | undefined;
    /**
     * Notifies application menu that it has been updated
     */
    updated(): void;
    /**
     * Closes the panel area controlled by switcher
     */
    closeSwitcherPanel(): void;
    updateLazy(applicationMenu: SohoApplicationMenuComponent, target: any): void;
    toggleAndSelectHeader(applicationMenu: SohoApplicationMenuComponent, header: any): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoApplicationMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoApplicationMenuComponent, "nav[soho-application-menu]", never, { "breakpoint": { "alias": "breakpoint"; "required": false; }; "openOnLarge": { "alias": "openOnLarge"; "required": false; }; "dismissOnClickMobile": { "alias": "dismissOnClickMobile"; "required": false; }; "triggers": { "alias": "triggers"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "savePosition": { "alias": "savePosition"; "required": false; }; "onExpandSwitcher": { "alias": "onExpandSwitcher"; "required": false; }; "onCollapseSwitcher": { "alias": "onCollapseSwitcher"; "required": false; }; "isPersonalizable": { "alias": "isPersonalizable"; "required": false; }; }, { "visibility": "visibility"; "accordionExpand": "accordionExpand"; "accordionCollapse": "accordionCollapse"; "menuVisibility": "menuVisibility"; "filtered": "filtered"; }, never, ["*"], true, never>;
}

declare class SohoApplicationMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoApplicationMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoApplicationMenuModule, never, [typeof SohoApplicationMenuComponent], [typeof SohoApplicationMenuComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoApplicationMenuModule>;
}

declare class SohoArrangeDirective implements AfterViewInit, OnDestroy {
    private elementRef;
    private ngZone;
    private jQueryElement?;
    private _arrangeOptions;
    private arrange?;
    beforeArrange: EventEmitter<SohoArrangeEvent>;
    arrangeUpdate: EventEmitter<SohoArrangeEvent>;
    dragEnd: EventEmitter<SohoArrangeEvent>;
    set arrangeOptions(arrangeOptions: SohoArrangeOptions);
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    updated(settings?: SohoArrangeOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoArrangeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoArrangeDirective, "[soho-arrange]", never, { "arrangeOptions": { "alias": "arrangeOptions"; "required": false; }; }, { "beforeArrange": "beforeArrange"; "arrangeUpdate": "arrangeUpdate"; "dragEnd": "dragEnd"; }, never, never, true, never>;
}

declare class SohoArrangeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoArrangeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoArrangeModule, never, [typeof SohoArrangeDirective], [typeof SohoArrangeDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoArrangeModule>;
}

declare const NOOP: any;
/**
 * Base class for new components that need to support NgForms.
 */
declare class BaseControlValueAccessor<T> implements ControlValueAccessor {
    /** Current value. */
    private _value?;
    /** ControlValueAccessor method called when the attached control has changed, */
    protected _onChangeCallback: (_: T) => void;
    /** ControlValueAccessor method called when the attached control has touched. */
    private _onTouchedCallback;
    /** Gets the value for the control. */
    protected get internalValue(): T | undefined;
    /** Sets the value for the control. */
    protected set internalValue(newValue: T | undefined);
    /**
     * When touched.
     */
    protected touched(): void;
    /**
     * -------------------------------------------------
     * ControlValueAccessor implementation
     * -------------------------------------------------
     */
    /**
     * Write a new value to the element.
     */
    writeValue(value: T): void;
    /**
     * Set the function to be called when the control receives a change event.
     */
    registerOnChange(fn: (_: T) => void): void;
    /**
     * Set the function to be called when the control receives a touched event.
     */
    registerOnTouched(fn: () => void): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(_isDisabled: boolean): void;
}
/**
 * Provider - adds the contol value accessor.
 */
declare function provideControlValueAccessor(type: any): any;

declare class SohoAutoCompleteComponent extends BaseControlValueAccessor<string> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    /** Options. */
    private options;
    /** Defines the data to use, must be specified for this component. */
    set source(source: SohoAutoCompleteSource);
    /** Object is passed into the source method, and augmented with parameters. */
    set sourceArguments(sourceArguments: string);
    /** Menu template, appropriate markup is expected. */
    set template(template: string);
    /** if true, causes filter results that don't match case to be thrown out. */
    set caseSensitive(caseSensitive: boolean);
    /** Filters based on the first character('startsWidth') of the string, or the entire string('contains') */
    set filterMode(filterMode: SohoAutoCompleteFilterMode);
    /** Delay between key strokes on the keypad before the end of typing */
    set delay(delay: number);
    /** Width of the open menu */
    set width(width: SohoAutoCompleteWidth);
    /** Offset, the left or top offset */
    set offset(offset: SohoAutoCompleteOffset);
    /** Selects first item menu */
    set autoSelectFirstItem(autoSelectFirstItem: boolean);
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /**
     * Available Soho Template events as Output (EventEmitters passing the event)
     * Should match the Soho event names for the component
     *
     * @todo replace override of native attribute.
     */
    change: EventEmitter<SohoInputEvent[]>;
    selected: EventEmitter<Object[]>;
    beforeopen: EventEmitter<SohoAutoCompleteEvent>;
    get isAutoComplete(): boolean;
    /**
     * Local variables
     */
    private isDisabled?;
    private isReadOnly?;
    private jQueryElement;
    private autocomplete;
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    constructor(element: ElementRef);
    onKeyUp(_event: KeyboardEvent): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    /**
     * Handle the control being changed.
     */
    onChange(event: any[]): void;
    /**
     * Override writeValue to allow the mask input
     * element to be updated correctly.
     *
     * @param value - the new value
     */
    writeValue(value: any): void;
    getValue(): string | undefined;
    setValue(value: string): void;
    /** For async methods, reinit autocomplete `source` setting. */
    updated(): SohoAutoCompleteComponent;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAutoCompleteComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoAutoCompleteComponent, "input[soho-autocomplete]", never, { "source": { "alias": "source"; "required": false; }; "sourceArguments": { "alias": "sourceArguments"; "required": false; }; "template": { "alias": "template"; "required": false; }; "caseSensitive": { "alias": "caseSensitive"; "required": false; }; "filterMode": { "alias": "filterMode"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "width": { "alias": "width"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "autoSelectFirstItem": { "alias": "autoSelectFirstItem"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "change": "change"; "selected": "selected"; "beforeopen": "beforeopen"; }, never, ["*"], true, never>;
}

declare class SohoAutoCompleteModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoAutoCompleteModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoAutoCompleteModule, never, [typeof SohoAutoCompleteComponent], [typeof SohoAutoCompleteComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoAutoCompleteModule>;
}

declare class SohoBarComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isBar(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any>);
    /** Chart Type */
    set type(value: SohoBarType);
    /** Default is a single or stacked chart. */
    set isStacked(value: boolean);
    /** If true its a 100% bar chart. */
    set isNormalized(value: boolean);
    /** If true its a grouped bar chart. */
    set isGrouped(value: boolean);
    /** If false the legend will not be shown. */
    set showLegend(value: boolean);
    /** true|false - will do or not do the animation, 'initial' will do only first time the animation. */
    set animate(value: boolean);
    /** If true, the component will not resize when resizing the page. */
    set redrawOnResize(value: boolean);
    /** Use d3 format some examples can be found on http://bit.ly/1IKVhHh */
    set formatterString(value: string);
    /** The d3 axis format. */
    set format(value: string);
    /** A tooltip for the whole chart. */
    set tooltip(value: string);
    /** If true log scale is enabled. */
    set useLogScale(value: boolean);
    /** Settings for the chart ticks. Can set ticks: {format: d3Format, number: n} */
    set ticks(value: object);
    /** Show the in the axis lines or not. */
    set showLines(value: boolean);
    /** How far out than the outer circle should the labels be placed, this
     * may be useful to adjust for some labels. */
    set labelFactor(value: number);
    /** The number of pixels after which a label needs to be given a new line.
     * You may want to change this based on label data. */
    set wrapWidth(value: number);
    /** If true chart height will fit in parent available height. */
    set fitHeight(value: boolean);
    /** An empty message will be displayed when there is no chart data. */
    set emptyMessage(value: SohoEmptyMessageOptions);
    /**
     * Add extra attributes like id's to the component
     *
     * @param attributes - the array or object of attributes to add
     */
    set attributes(attributes: Array<Object> | Object);
    /** Events */
    selected: EventEmitter<SohoBarSelectEvent>;
    unselected: EventEmitter<SohoBarSelectEvent>;
    rendered: EventEmitter<Object>;
    dblclick: EventEmitter<Object>;
    /**
     * @todo replace override of native attribute
     */
    contextmenu: EventEmitter<Object[]>;
    private jQueryElement?;
    private bar?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    updated(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    setSelected(selected: SohoBarSelected): void;
    toggleSelected(selected: SohoBarSelected): void;
    getSelected(): SohoBarSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoBarComponent, "[soho-bar]", never, { "dataset": { "alias": "dataset"; "required": false; }; "type": { "alias": "type"; "required": false; }; "isStacked": { "alias": "isStacked"; "required": false; }; "isNormalized": { "alias": "isNormalized"; "required": false; }; "isGrouped": { "alias": "isGrouped"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "formatterString": { "alias": "formatterString"; "required": false; }; "format": { "alias": "format"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "useLogScale": { "alias": "useLogScale"; "required": false; }; "ticks": { "alias": "ticks"; "required": false; }; "showLines": { "alias": "showLines"; "required": false; }; "labelFactor": { "alias": "labelFactor"; "required": false; }; "wrapWidth": { "alias": "wrapWidth"; "required": false; }; "fitHeight": { "alias": "fitHeight"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "selected": "selected"; "unselected": "unselected"; "rendered": "rendered"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoBarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoBarModule, never, [typeof SohoBarComponent], [typeof SohoBarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoBarModule>;
}

declare class SohoBlockGridComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    private jQueryElement?;
    private blockgrid?;
    get isBlockGrid(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any> | undefined);
    get dataset(): Array<any> | undefined;
    /** Defines the selection type. */
    set selectable(selectable: SohoBlockGridSelectable);
    get selectable(): SohoBlockGridSelectable;
    /** Defines whether or not paging is active. */
    set paging(paging: boolean | undefined);
    get paging(): boolean | undefined;
    /** Defines the current page size */
    set pagesize(pagesize: number | undefined);
    get pagesize(): number | undefined;
    /** Defines the array of selectable page sizes */
    set pagesizes(pagesizes: Array<number> | undefined);
    get pagesizes(): Array<number> | undefined;
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    selected: EventEmitter<Object[]>;
    deselected: EventEmitter<Object[]>;
    activated: EventEmitter<Object[]>;
    deactivated: EventEmitter<Object[]>;
    page: EventEmitter<Object[]>;
    pagesizechange: EventEmitter<Object[]>;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    /** Reinit blockgrid settings */
    updated(settings: any): SohoBlockGridComponent;
    activateBlock(idx: number): void;
    deactivateBlock(): void;
    selectBlocks(idx: number[]): void;
    private onSelected;
    private onDeselected;
    private onActivated;
    private onDeactivated;
    private onPage;
    private onPageSizeChange;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBlockGridComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoBlockGridComponent, "[soho-blockgrid]", never, { "dataset": { "alias": "dataset"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "paging": { "alias": "paging"; "required": false; }; "pagesize": { "alias": "pagesize"; "required": false; }; "pagesizes": { "alias": "pagesizes"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "selected": "selected"; "deselected": "deselected"; "activated": "activated"; "deactivated": "deactivated"; "page": "page"; "pagesizechange": "pagesizechange"; }, never, ["*"], true, never>;
}

declare class SohoBlockGridModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBlockGridModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoBlockGridModule, never, [typeof SohoBlockGridComponent], [typeof SohoBlockGridComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoBlockGridModule>;
}

/**
 * Soho Breadcrumb Component
 */
declare class SohoBreadcrumbComponent implements AfterViewInit, OnDestroy, OnInit {
    private element;
    private ngZone;
    private jQueryElement?;
    private breadcrumbAPI?;
    private options;
    get isBreadcrumb(): boolean;
    /** Allow Breadcrumb Definition by Input */
    set breadcrumbs(items: SohoBreadcrumbItemOptions[] | undefined);
    get breadcrumbs(): SohoBreadcrumbItemOptions[] | undefined;
    /** Allow change to alternate styling via Input **/
    set alternate(val: boolean);
    get alternate(): boolean;
    /** Add truncatling behavior when a lot of items */
    set truncate(truncate: boolean | undefined);
    get truncate(): boolean | undefined;
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /** Provides access to the internal array of currently-invoked IDS Breadcrumb APIs */
    get breadcrumbAPIs(): SohoBreadcrumbItemStatic[];
    /** Provides access to the IDS Breadcrumb's disabled property */
    get disabled(): boolean | undefined;
    /**
     * Constructor
     *
     * @param elementRef - the element matching the component's selector.
     */
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    ngOnInit(): void;
    enable(): void;
    disable(): void;
    /**
     * Adds a new breadcrumb item to the list
     */
    add(settings?: SohoBreadcrumbItemOptions, doRender?: boolean): void;
    /**
     * Removes a single breadcrumb item from the list
     */
    remove(item: SohoBreadcrumbRef, doRender?: boolean): void;
    /**
     * Removes all breadcrumb items from the list
     */
    removeAll(doRender?: boolean): void;
    /**
     * Gets references related to a particular Breadcrumb Item.
     * The return object contains:
     * - 'a' : a reference to the breadcrumb item's anchor tag
     * - 'api' : a reference to the breadcrumb item's API
     * - 'i' : a number representing the current index of the breadcrumb item.
     */
    getBreadcrumbItem(item: SohoBreadcrumbRef): SohoBreadcrumbTargetObject | undefined;
    /**
     * Takes a reference to a Breadcrumb item and makes it "Current",
     * styling it with bold text and popping it out of truncation.
     */
    makeCurrent(item: SohoBreadcrumbRef): void;
    /**
     * Updates the Breadcrumb List with new incoming settings
     */
    updated(settings?: SohoBreadcrumbOptions): void;
    /**
     * Destroys this component and tears down the IDS Breadcrumb
     */
    destroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBreadcrumbComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoBreadcrumbComponent, "[soho-breadcrumb]", never, { "breadcrumbs": { "alias": "breadcrumbs"; "required": false; }; "alternate": { "alias": "alternate"; "required": false; }; "truncate": { "alias": "truncate"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class SohoBreadcrumbListComponent {
    isBreadcrumbList: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBreadcrumbListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoBreadcrumbListComponent, "[soho-breadcrumb-list]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoBreadcrumbModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBreadcrumbModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoBreadcrumbModule, never, [typeof SohoBreadcrumbComponent, typeof SohoBreadcrumbListComponent], [typeof SohoBreadcrumbComponent, typeof SohoBreadcrumbListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoBreadcrumbModule>;
}

declare class SohoBulletComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isBullet(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: SohoDatasetOptions);
    /** true|false - will do or not do the animation and 'initial' will do only first time the animation. */
    set animate(value: any);
    /** If true, the component will not resize when resizing the page. There is tooltip values provided.
     * It will not be shown. If you still want lines at the lower breakpoint you can set this to true */
    set redrawOnResize(value: boolean);
    selected: EventEmitter<SohoLineSelectEvent>;
    rendered: EventEmitter<Object>;
    dblclick: EventEmitter<Object>;
    /**
     * @todo replace override of native attribute
     */
    contextmenu: EventEmitter<Object[]>;
    private jQueryElement?;
    private bullet?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    updated(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBulletComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoBulletComponent, "[soho-bullet]", never, { "dataset": { "alias": "dataset"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; }, { "selected": "selected"; "rendered": "rendered"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoBulletModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBulletModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoBulletModule, never, [typeof SohoBulletComponent], [typeof SohoBulletComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoBulletModule>;
}

/**
 * Angular Wrapper for the SoHo Busy Indicator control.
 *
 * This component searches for an element, annotated with the soho-busyindicator attribute,
 * and then matches this component to it.
 * <br>
 * The characteristics of the component can be controlled using the set of inputs.
 * <br>
 * When activated, this control will display the busy indicator over the control appropriately.
 */
declare class SohoBusyIndicatorDirective implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    private options;
    private jQueryElement?;
    private initiallyActive?;
    private busyindicator?;
    private updateBusyIndicator;
    afterstart: EventEmitter<SohoBusyIndicatorEvent>;
    /**
     * This event is fired when 'timeToComplete' milliseconds is reached
     * after the indicator is opened.
     *
     * @todo replace override of native attribute
     */
    complete: EventEmitter<SohoBusyIndicatorEvent>;
    set blockUI(blockUI: boolean);
    set displayDelay(displayDelay: number);
    set timeToComplete(timeToComplete: number);
    /** Custom Text To Show or Will Show Localized 'Loading...' */
    set text(text: string);
    /** Controls the activated state of the busy indicator. */
    set activated(value: boolean | undefined);
    /**
     * Display an overlay that prevents interaction,
     * but appears transparent instead of gray.
     */
    set transparentOverlay(transparentOverlay: boolean);
    /**
     * To display only the overlay w/o the badge and text. Useful to stop input to a component
     * that doesn't already have another mechanism (like a disabled state).
     */
    set overlayOnly(overlayOnly: boolean);
    /**
     * To display only the overlay w/o the badge and text. Useful to stop input to a component
     * that doesn't already have another mechanism (like a disabled state).
     */
    set attributes(attributes: Array<Object> | Object);
    /**
     * To get the attributes of the busy indicator. Useful for things like getting an indicator based on an Id.
     */
    get attributes(): Object | Array<Object>;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching the component's selector.
     */
    constructor(elementRef: ElementRef, ngZone: NgZone);
    /**
     * Closes the indicator, if open.
     */
    close(fromEvent: boolean): void;
    /**
     * Displays the busy indicator.
     */
    open(): void;
    isActive(): boolean | undefined;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    /**
     * Publishes the event, after annotating the event.
     */
    private onAfterStart;
    /**
     * Publishes the event, after annotating the event.
     */
    private onComplete;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBusyIndicatorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoBusyIndicatorDirective, "[soho-busyindicator]", never, { "blockUI": { "alias": "blockUI"; "required": false; }; "displayDelay": { "alias": "displayDelay"; "required": false; }; "timeToComplete": { "alias": "timeToComplete"; "required": false; }; "text": { "alias": "text"; "required": false; }; "activated": { "alias": "activated"; "required": false; }; "transparentOverlay": { "alias": "transparentOverlay"; "required": false; }; "overlayOnly": { "alias": "overlayOnly"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "afterstart": "afterstart"; "complete": "complete"; }, never, never, true, never>;
}
/**
 * Customised event object.
 */
interface SohoBusyIndicatorEvent {
    /** Event Type. */
    type: 'afterstart' | 'complete';
    /** Source Component. */
    component: SohoBusyIndicatorDirective;
    /** Full JQuery Event. */
    event: JQuery.TriggeredEvent;
}

declare class SohoBusyIndicatorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoBusyIndicatorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoBusyIndicatorModule, never, [typeof SohoBusyIndicatorDirective], [typeof SohoBusyIndicatorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoBusyIndicatorModule>;
}

/**
 * Supported button types.
 */
type SohoButtonType = 'btn' | 'primary' | 'secondary' | 'tertiary' | 'icon' | 'favorite' | 'modal' | 'modal-primary' | 'primary-destructive' | 'tertiary-destructive' | 'primary-generative' | 'tertiary-generative' | 'icon-generative';
declare class SohoButtonComponent implements AfterViewInit, OnDestroy, OnInit {
    private element;
    private ngZone;
    static BTN: SohoButtonType;
    static PRIMARY: SohoButtonType;
    static SECONDARY: SohoButtonType;
    static TERTIARY: SohoButtonType;
    static ICON: SohoButtonType;
    static FAVORITE: SohoButtonType;
    static MODAL: SohoButtonType;
    static MODAL_PRIMARY: SohoButtonType;
    static PRIMARY_DESTRUCTIVE: SohoButtonType;
    static TERTIARY_DESTRUCTIVE: SohoButtonType;
    static PRIMARY_GENERATIVE: SohoButtonType;
    static TERTIARY_GENERATIVE: SohoButtonType;
    static ICON_GENERATIVE: SohoButtonType;
    /** Reference to the jQuery control. */
    private jQueryElement?;
    /** Reference to the Soho control api. */
    private button?;
    /** The type of the button. */
    private buttonType?;
    private _buttonOptions;
    private _isToggle;
    private _isTogglePressed;
    private _iconAlign;
    private _isPressed;
    /**
     * The type of the button, defaulting to 'secondary'.
     *
     * Allow override of input, to match component selector.
     */
    set sohoButton(type: SohoButtonType | "" | undefined);
    /**
     * Sets the button options
     */
    set buttonOptions(buttonOptions: SohoButtonOptions);
    get buttonOptions(): SohoButtonOptions;
    set toggleOnIcon(toggleOnIcon: string);
    set toggleOffIcon(toggleOffIcon: string);
    set replaceText(replaceText: boolean);
    set hideMenuArrow(value: boolean | undefined);
    get hideMenuArrow(): boolean | undefined;
    /**
     * Used to add a bigger hit area (for mobile)
     */
    set hitbox(value: boolean | undefined);
    get hitbox(): boolean | undefined;
    /**
     * Used to set a notification badge on the button
     */
    set notificationBadge(value: boolean | undefined);
    get notificationBadge(): boolean | undefined;
    /**
     * Set the position and color of the notification badge on the button
     */
    set notificationBadgeOptions(value: SohoNotificationBadgeOptions | undefined);
    get notificationBadgeOptions(): SohoNotificationBadgeOptions | undefined;
    /**
     * Used to set an extra class on the soho-icon being used by soho-button.
     * Useful to set emerald06-color azure10-color to change the icon color.
     */
    extraIconClass?: string;
    /**
     * Whether this button should be a toggle button or not. Alternate toggle on/off icons
     * can be used through toggleOnIcon/toggleOffIcon inputs.
     */
    set isToggle(isToggle: boolean);
    get isToggle(): boolean;
    /**
     * Whether the toggle button should be in a pressed state or not.
     */
    set isTogglePressed(isTogglePressed: boolean);
    get isTogglePressed(): boolean;
    /**
     * The icon to be used
     *  - shows when the state is true if toggle has a value
     */
    icon?: string;
    /**
     * The icon placement
     */
    set iconAlign(iconAlign: string);
    get iconAlign(): string;
    /** Sets the button type to 'submit' when true. */
    isSubmit: boolean;
    /** Sets whether the button should have a ripple effect on click. */
    ripple: boolean;
    /**
     * Binary state (toggle):
     *  0 - shows toggle
     *  1 - shows icon (default)
     *
     *  @deprecated use isToggle=true input instead along with toggleOnIcon/toggleOffIcon options
     */
    state?: boolean;
    /**
     * The icon to be used when the state is false.
     *
     * @deprecated use isToggle=true input instead along with toggleOnIcon/toggleOffIcon options
     */
    toggle?: string;
    /**
     * Sets the expandable-expander class to be placed on the button for the
     * soho-expandablearea to use as it's expand/collapse trigger
     *
     */
    expandableExpander: boolean;
    get btn(): boolean;
    get btnPrimary(): boolean;
    get btnSecondary(): boolean;
    get btnTertiary(): boolean;
    get btnIcon(): boolean;
    get btnToggle(): boolean;
    get btnModal(): boolean;
    get btnModalPrimary(): boolean;
    get btnDestructive(): boolean;
    get btnGenerative(): boolean;
    get btnTogglePressed(): boolean;
    get iconFavorite(): boolean;
    moveToLeft: any;
    moveToRight: any;
    moveToSelected: any;
    get noRipple(): boolean;
    get type(): "submit" | "button";
    get isExpandableExpander(): boolean;
    /**
     * @deprecated no longer needed once this.toggle is removed.
     */
    toggleState(): void;
    get ariaPressed(): boolean;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching the component's selector.
     */
    constructor(element: ElementRef, ngZone: NgZone);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    get hasIcon(): boolean | "" | undefined;
    get hasIconEnd(): boolean | "" | undefined;
    get currentIcon(): string | undefined;
    /**
     * @deprecated use isToggle and isTogglePressed instead.
     */
    isPressed(): boolean;
    performAnimation(delay?: Number): void;
    startAnimation(): void;
    stopAnimation(): void;
    updated(settings?: SohoButtonOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoButtonComponent, "button[soho-button]", never, { "sohoButton": { "alias": "soho-button"; "required": false; }; "buttonOptions": { "alias": "buttonOptions"; "required": false; }; "toggleOnIcon": { "alias": "toggleOnIcon"; "required": false; }; "toggleOffIcon": { "alias": "toggleOffIcon"; "required": false; }; "replaceText": { "alias": "replaceText"; "required": false; }; "hideMenuArrow": { "alias": "hideMenuArrow"; "required": false; }; "hitbox": { "alias": "hitbox"; "required": false; }; "notificationBadge": { "alias": "notificationBadge"; "required": false; }; "notificationBadgeOptions": { "alias": "notificationBadgeOptions"; "required": false; }; "extraIconClass": { "alias": "extraIconClass"; "required": false; }; "isToggle": { "alias": "isToggle"; "required": false; }; "isTogglePressed": { "alias": "isTogglePressed"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "iconAlign": { "alias": "iconAlign"; "required": false; }; "isSubmit": { "alias": "isSubmit"; "required": false; }; "ripple": { "alias": "ripple"; "required": false; }; "state": { "alias": "state"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; }; "expandableExpander": { "alias": "expandableExpander"; "required": false; }; "moveToLeft": { "alias": "moveToLeft"; "required": false; }; "moveToRight": { "alias": "moveToRight"; "required": false; }; "moveToSelected": { "alias": "moveToSelected"; "required": false; }; }, {}, never, ["*", "div.disabled-tooltip"], true, never>;
}

declare class SohoIconUseComponent {
    get href(): string;
    icon?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconUseComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconUseComponent, "use", never, { "icon": { "alias": "icon"; "required": false; }; }, {}, never, never, true, never>;
}
declare class SohoIconComponent {
    private elementRef;
    isIcon: boolean;
    get ariaHidden(): boolean | null;
    focusable: boolean;
    role: string;
    isEmptyState: boolean;
    /**
     * Extra class that will be placed on the soho-icon element.
     * Useful to set emerald06-color azure10-color to change the icon color.
     */
    set extraIconClass(extraIconClass: string | undefined);
    set alert(alert: boolean | undefined);
    get alert(): boolean | undefined;
    set icon(icon: string | undefined);
    get icon(): string | undefined;
    private _alert?;
    private _icon?;
    private _extraIconClass?;
    constructor(elementRef: ElementRef);
    private setAlertIcon;
    private setExtraIconsClass;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconComponent, "svg[soho-icon]", never, { "isEmptyState": { "alias": "isEmptyState"; "required": false; }; "extraIconClass": { "alias": "extraIconClass"; "required": false; }; "alert": { "alias": "alert"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoIconsComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsComponent, "soho-icons", never, {}, {}, never, never, true, never>;
}

declare class SohoIconsEmptyComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsEmptyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsEmptyComponent, "soho-icons-empty", never, {}, {}, never, never, true, never>;
}

declare class SohoIconsEmptyClassicComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsEmptyClassicComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsEmptyClassicComponent, "soho-icons-empty-classic", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated All icons are now in one file per theme (theme-classic-svg.html or theme-new-svg.html),
 * and hence this component is deprecated and will be removed in the next major release.
 */
declare class SohoIconsExtendedComponent {
    none: string;
    constructor();
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsExtendedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsExtendedComponent, "soho-icons-ext", never, {}, {}, never, never, true, never>;
}

declare class SohoIconsUpliftComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsUpliftComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsUpliftComponent, "soho-icons-uplift", never, {}, {}, never, never, true, never>;
}

declare class SohoIconsEmptyUpliftComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsEmptyUpliftComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsEmptyUpliftComponent, "soho-icons-empty-uplift", never, {}, {}, never, never, true, never>;
}

declare class SohoIconsNewComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsNewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsNewComponent, "soho-icons-new", never, {}, {}, never, never, true, never>;
}

/**
 * @deprecated As of 15.0 the "new" or "colorful" icons can be used with `SohoIconsEmptyComponent` (`<soho-icons-empty icons="new | colorful">`) instead.
 */
declare class SohoIconsEmptyNewComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsEmptyNewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsEmptyNewComponent, "soho-icons-empty-new", never, {}, {}, never, never, true, never>;
}

declare class SohoIconsAppComponent {
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconsAppComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoIconsAppComponent, "soho-icons-app", never, {}, {}, never, never, true, never>;
}

declare class SohoIconModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoIconModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoIconModule, never, [typeof SohoIconComponent, typeof SohoIconUseComponent, typeof SohoIconsComponent, typeof SohoIconsEmptyComponent, typeof SohoIconsEmptyClassicComponent, typeof SohoIconsExtendedComponent, typeof SohoIconsUpliftComponent, typeof SohoIconsEmptyUpliftComponent, typeof SohoIconsNewComponent, typeof SohoIconsEmptyNewComponent, typeof SohoIconsAppComponent], [typeof SohoIconComponent, typeof SohoIconsComponent, typeof SohoIconsEmptyComponent, typeof SohoIconsEmptyClassicComponent, typeof SohoIconsExtendedComponent, typeof SohoIconsUpliftComponent, typeof SohoIconsEmptyUpliftComponent, typeof SohoIconsNewComponent, typeof SohoIconsEmptyNewComponent, typeof SohoIconsAppComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoIconModule>;
}

declare class SohoButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoButtonModule, never, [typeof SohoIconModule, typeof SohoButtonComponent], [typeof SohoButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoButtonModule>;
}

declare class SohoButtonsetComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ref;
    private ngZone;
    /** Reference to the jQuery control. */
    private jQueryElement?;
    /** Reference to the Soho buttonset api. */
    private buttonset?;
    /** Settings (options) */
    private settings;
    /** Flag to force an update of the control after the view is created. */
    private runUpdatedOnCheck?;
    /**
     * Constructor.
     *
     * @param element - the element matching the component's selector.
     * @param ref - change detector reference for the component.
     * @param ngZone - angular zone.
     */
    constructor(element: ElementRef, ref: ChangeDetectorRef, ngZone: NgZone);
    /**
     * The list of buttons definitions.
     *
     * @params buttons - list of modal button definitions to use.
     */
    set buttons(buttons: SohoButtonOptions[] | undefined);
    get buttons(): SohoButtonOptions[] | undefined;
    /**
     * Detect existing buttons in the markup rather than generating
     * new button markup.
     */
    set detectHTMLButtons(value: boolean | undefined);
    get detectHTMLButtons(): boolean | undefined;
    /**
     * Styles to add to any generated button markup.
     */
    set style(style: string | undefined);
    get style(): string | undefined;
    get buttonAPIs(): SohoButtonStatic[];
    /**
     * Disable all the buttons on the buttonset.
     *
     * @param val whether or not the Buttonset is disabled.
     */
    set disabled(val: boolean);
    /**
     * Adds a new button to the Buttonset.
     *
     * @param button button definition.
     * @param [doAddDOM=false] if true, appends the new element to the Buttonset container after creation/update.
     */
    add(button: SohoButtonOptions, doAddDOM?: boolean): void;
    /**
     * Removes a button from the buttonset, based on the API, HTML Element or element id.
     *
     * @param buttonAPI a button, an html element, or button id.
     * @param [doRemoveDOM=false] if true, removes the button's HTML from the page.
     */
    remove(buttonAPI?: SohoButtonStatic | HTMLButtonElement | string, doRemoveDOM?: boolean): void;
    /**
     * Removes ALL buttons from the buttonset
     *
     * @param [doRemoveDOM=false] if true, removes the button's HTML from the page.
     */
    removeAll(doRemoveDOM?: boolean): void;
    /**
     * Returns a ButtonSet API in a specified place in the buttons array.
     *
     * @param idx index to target
     * @returns the Button API at the given index
     */
    at(idx: number): SohoButtonStatic;
    /**
     * Provides a JSON-compatible data representation of this button component for use with
     * higher-level components.
     *
     * @param addContextElement if true, adds a reference to this button element to the return data (NOT JSON-compatible).
     * @returns JSON-compatible representation of this button's configuration.
     */
    toData(addContextElement: boolean): string;
    /**
     * Update the component with new settings.
     *
     * @param settings The settings you would like to modify.
     * @returns This component's API.
     */
    updated(settings: SohoButtonsetOptions): SohoButtonsetStatic;
    /**
     * Teardown and remove any added markup and events.
     */
    destroy(): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    private markForRefresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoButtonsetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoButtonsetComponent, "div[soho-buttonset]", never, { "buttons": { "alias": "buttons"; "required": false; }; "detectHTMLButtons": { "alias": "detectHTMLButtons"; "required": false; }; "style": { "alias": "style"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoButtonsetModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoButtonsetModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoButtonsetModule, never, [typeof SohoButtonsetComponent], [typeof SohoButtonsetComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoButtonsetModule>;
}

/********************************************************************
 * Calendar Week View Element
 *******************************************************************/
declare class SohoCalendarWeekViewComponent {
    isCalendarWeekView: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCalendarWeekViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCalendarWeekViewComponent, "div[soho-calendar-week-view]", never, {}, {}, never, ["*"], true, never>;
}
/********************************************************************
 * Calendar Month View Element
 *******************************************************************/
declare class SohoCalendarMonthViewComponent {
    isCalendarMonthView: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCalendarMonthViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCalendarMonthViewComponent, "div[soho-calendar-monthview]", never, {}, {}, never, ["*"], true, never>;
}
/********************************************************************
 * Main Calendar component
 *******************************************************************/
declare class SohoCalendarComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    ref: ChangeDetectorRef;
    isCalendar: boolean;
    set calendarOptions(calendarOptions: SohoCalendarOptions | undefined);
    get calendarOptions(): SohoCalendarOptions | undefined;
    set calendarWeekOptions(calendarWeekOptions: SohoCalendarWeekOptions | undefined);
    get calendarWeekOptions(): SohoCalendarWeekOptions | undefined;
    set disable(disable: SohoDatePickerDisable);
    get disable(): SohoDatePickerDisable;
    set dayLegend(dayLegend: Array<SohoDatePickerLegend>);
    get dayLegend(): Array<SohoDatePickerLegend>;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /**
     * An array of objects with data for the event types.
     */
    set eventTypes(eventTypes: SohoCalendarEventType[] | undefined);
    get eventTypes(): SohoCalendarEventType[] | undefined;
    /**
     * An array of objects with data for the events.
     */
    set events(events: SohoCalendarEvent[]);
    get events(): SohoCalendarEvent[];
    set customSort(customSort: SortEvent);
    /**
     * The name of the locale to use for this instance. If not set the current locale will be used.
     */
    set locale(locale: string);
    get locale(): string;
    /**
     * Initial month to show.
     */
    set month(month: number | undefined);
    get month(): number | undefined;
    /**
     * Initial month to show.
     */
    set day(day: number | undefined);
    get day(): number | undefined;
    /**
     * Initial year to show.
     */
    set year(year: number | undefined);
    get year(): number | undefined;
    /**
     * If false the dropdown to change views will not be shown.
     */
    set showViewChanger(showViewChanger: boolean | undefined);
    get showViewChanger(): boolean | undefined;
    /**
     * If false the legend will not show below.
     */
    set showEventLegend(showEventLegend: boolean | undefined);
    get showEventLegend(): boolean | undefined;
    /**
     * If false the mouseover text or day event will not be shown.
     */
    set eventTooltip(eventTooltip: string | SohoCalendarTooltipFunction);
    get eventTooltip(): string | SohoCalendarTooltipFunction;
    /**
     * If false the mouseover text for event icon will not be shown.
     */
    set iconTooltip(iconTooltip: string | SohoCalendarTooltipFunction);
    get iconTooltip(): string | SohoCalendarTooltipFunction;
    /**
     * Fires when a month is rendered, allowing you to pass back events or event types to show.
     */
    set renderMonthCallback(renderMonthCallback: Function);
    get renderMonthCallback(): Function;
    /**
     * Fires when a month day is clicked. Allowing you to do something.
     */
    set selectedCallback(selectedCallback: Function | undefined);
    get selectedCallback(): Function | undefined;
    /**
     * The ID of the template used for the events.
     */
    set template(template: string | undefined);
    get template(): string | undefined;
    /**
     * How many days in advance should we show in the upcoming events pane.
     */
    set upcomingEventDays(upcomingEventDays: number | undefined);
    get upcomingEventDays(): number | undefined;
    /**
     * The ID of the template used for the modal dialog on events.
     */
    set modalTemplate(modalTemplate: string | undefined);
    get modalTemplate(): string | undefined;
    /**
     * ID of the menu to use for an event right click context menu
     */
    set menuId(menuId: string | undefined);
    get menuId(): string | undefined;
    /**
     * Callback for the  right click context menu
     */
    set menuSelected(menuSelected: Function | undefined);
    get menuSelected(): Function | undefined;
    /**
     * Initial event properties for the new events dialog.
     */
    set newEventDefaults(newEventDefaults: SohoCalendarEvent | undefined);
    get newEventDefaults(): SohoCalendarEvent | undefined;
    /**
     * Call back for when the view changer is changed
     */
    set changeViewCallback(changeViewCallback: Function | undefined);
    get changeViewCallback(): Function | undefined;
    /**
     * Deterimines if the today button should be shown.
     */
    set showToday(showToday: boolean | undefined);
    get showToday(): boolean | undefined;
    /**
     * Configure date range for calendar
     */
    set displayRange(displayRange: Object | undefined);
    get displayRange(): Object | undefined;
    /**
     * Configure day of week setting
     */
    set firstDayOfWeek(day: number);
    get firstDayOfWeek(): number;
    selected: EventEmitter<SohoCalendarDateSelectedEvent>;
    monthRendered: EventEmitter<SohoCalendarRenderMonthEvent>;
    eventClick: EventEmitter<SohoCalendarEventClickEvent>;
    eventDblClick: EventEmitter<SohoCalendarEventClickEvent>;
    eventContextMenu: EventEmitter<SohoCalendarEventClickEvent>;
    dayClick: EventEmitter<SohoCalendarDayClickEventData>;
    /**
     * Local variables
     */
    private jQueryElement?;
    private calendar?;
    private _calendarOptions?;
    private _calendarWeekOptions?;
    private updateRequired?;
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    onSelectedEvent(event: SohoCalendarDateSelectedEvent): void;
    onMonthRenderedEvent(event: SohoCalendarRenderMonthEvent): void;
    onEventClick(event: SohoCalendarEventClickEvent): void;
    onEventDblClick(event: SohoCalendarEventClickEvent): void;
    onEventContextMenu(event: SohoCalendarEventClickEvent): void;
    onEventDayClick(event: SohoCalendarDayClickEventData): void;
    /**
     * Get the current selected date on the calendar.
     *
     * @returns the currently selected date on the control.
     */
    currentDate(): Date;
    /**
     * Get the events and date for the currently selected calendar day.
     *
     * @param date The date to find the events for.
     * @returns dayEvents An object with all the events and the event date.
     */
    getDayEvents(date: Date): SohoCalendarDayEvents;
    /**
     * Add a new event via the event object and show it if it should be visible in the calendar.
     *
     * @param event The event object with common event properties.
     */
    addEvent(event: SohoCalendarEvent): void;
    /**
     * Update an event via the event object and show it if it should be visible in the calendar.
     * It uses the event id to do this.
     *
     * @param event The event object with common event properties.
     */
    updateEvent(event: SohoCalendarEvent): void;
    /**
     * Allows to update the events or event types after the calendar renders.
     *
     * @param events An array of events.
     * @param eventTypes An array of event types.
     */
    updateEvents(events: SohoCalendarEvent[], eventTypes: SohoCalendarEventType[]): void;
    /**
     * Remove an event from the dataset and page. It uses the id property.
     *
     * @param event The event object with common event properties.
     */
    deleteEvent(event: SohoCalendarEvent): void;
    /**
     * Show a modal used to add/edit events. This uses the modalTemplate setting for the modal contents.
     *
     * @param event The event object with common event properties for defaulting fields in the template.
     * @param done The callback for when the modal closes.
     */
    showEventModal(event: SohoCalendarEvent[], done: Function): void;
    /**
     * @returns whether or not this Modal is currently being displayed
     */
    modalVisible(): boolean;
    /**
     * Remove all events from the calendar
     */
    clearEvents(): void;
    /**
     * Handle updated settings and values.
     */
    updated(settings?: SohoCalendarOptions): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCalendarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCalendarComponent, "[soho-calendar]", never, { "calendarOptions": { "alias": "calendarOptions"; "required": false; }; "calendarWeekOptions": { "alias": "calendarWeekOptions"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "dayLegend": { "alias": "dayLegend"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "eventTypes": { "alias": "eventTypes"; "required": false; }; "events": { "alias": "events"; "required": false; }; "customSort": { "alias": "customSort"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "month": { "alias": "month"; "required": false; }; "day": { "alias": "day"; "required": false; }; "year": { "alias": "year"; "required": false; }; "showViewChanger": { "alias": "showViewChanger"; "required": false; }; "showEventLegend": { "alias": "showEventLegend"; "required": false; }; "eventTooltip": { "alias": "eventTooltip"; "required": false; }; "iconTooltip": { "alias": "iconTooltip"; "required": false; }; "renderMonthCallback": { "alias": "renderMonthCallback"; "required": false; }; "selectedCallback": { "alias": "selectedCallback"; "required": false; }; "template": { "alias": "template"; "required": false; }; "upcomingEventDays": { "alias": "upcomingEventDays"; "required": false; }; "modalTemplate": { "alias": "modalTemplate"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; "menuSelected": { "alias": "menuSelected"; "required": false; }; "newEventDefaults": { "alias": "newEventDefaults"; "required": false; }; "changeViewCallback": { "alias": "changeViewCallback"; "required": false; }; "showToday": { "alias": "showToday"; "required": false; }; "displayRange": { "alias": "displayRange"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; }, { "selected": "selected"; "monthRendered": "monthRendered"; "eventClick": "eventClick"; "eventDblClick": "eventDblClick"; "eventContextMenu": "eventContextMenu"; "dayClick": "dayClick"; }, never, ["*"], true, never>;
}

declare class SohoCalendarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCalendarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoCalendarModule, never, [typeof SohoCalendarComponent, typeof SohoCalendarMonthViewComponent, typeof SohoCalendarWeekViewComponent], [typeof SohoCalendarComponent, typeof SohoCalendarMonthViewComponent, typeof SohoCalendarWeekViewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoCalendarModule>;
}

declare class SohoCardsComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    get isCards(): boolean;
    /** Reference to the Soho control api. */
    private cards?;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    private jQueryElement?;
    private options;
    private card?;
    /** Defines the data to use, must be specified for this component */
    set dataset(dataset: Array<any> | undefined);
    get dataset(): Array<any> | undefined;
    /** Defines the selection type of cards */
    set selectable(selectable: SohoCardsSelectable);
    get selectable(): SohoCardsSelectable;
    updated(settings: any): SohoCardsComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCardsComponent, "[soho-cards]", never, { "dataset": { "alias": "dataset"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class SohoCardActionableComponent {
    get isCardActionable(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardActionableComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCardActionableComponent, "soho-card-actionable", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoCardHeaderComponent {
    get isCardHeader(): boolean;
    flex: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCardHeaderComponent, "soho-card-header", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoCardContentComponent {
    get isCardContent(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCardContentComponent, "soho-card-content", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoCardPaneComponent {
    get isCardPane(): boolean;
    none: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardPaneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCardPaneComponent, "soho-card-pane", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoCardComponent implements AfterViewInit, OnDestroy, OnInit {
    private element;
    private ngZone;
    id: string | undefined;
    expandableHeader: boolean | undefined;
    verticalButtonAction: boolean | undefined;
    autoHeight: boolean | undefined;
    block: string;
    get isCard(): boolean;
    get isExpandableHeader(): boolean | undefined;
    get isAutoHeight(): boolean | undefined;
    set bordered(value: boolean | string | undefined);
    set noHeader(value: boolean | undefined);
    set contentPaddingX(value: number | undefined);
    set contentPaddingY(value: number | undefined);
    set noShadow(value: boolean);
    set detailRefId(value: string | undefined);
    set closed(value: boolean | undefined);
    /**
     * Closed the state of the component
     */
    get closed(): boolean | undefined;
    set attributes(value: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /** Html template string */
    set template(template: string);
    updated(settings: any): SohoCardComponent;
    toggle?: Observable<boolean>;
    beforeexpand: EventEmitter<Object>;
    beforecollapse: EventEmitter<Object>;
    expand: EventEmitter<Object>;
    collapse: EventEmitter<Object>;
    afterexpand: EventEmitter<Object>;
    aftercollapse: EventEmitter<Object>;
    selected: EventEmitter<Object>;
    deselected: EventEmitter<Object>;
    private jQueryElement?;
    private options;
    private cards?;
    private _closed?;
    constructor(element: ElementRef, ngZone: NgZone);
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Toggles the state of the expandable card based on the passed param.
     */
    toggleOpen(open: boolean): void;
    close(): void;
    open(): void;
    private onBeforeExpand;
    private onBeforeCollapse;
    private onExpand;
    private onCollapse;
    private onAfterExpand;
    private onAfterCollapse;
    private onSelected;
    private onDeselected;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCardComponent, "soho-card", never, { "id": { "alias": "soho-card"; "required": false; }; "expandableHeader": { "alias": "expandableHeader"; "required": false; }; "verticalButtonAction": { "alias": "verticalButtonAction"; "required": false; }; "autoHeight": { "alias": "autoHeight"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; "noHeader": { "alias": "noHeader"; "required": false; }; "contentPaddingX": { "alias": "contentPaddingX"; "required": false; }; "contentPaddingY": { "alias": "contentPaddingY"; "required": false; }; "noShadow": { "alias": "noShadow"; "required": false; }; "detailRefId": { "alias": "detailRefId"; "required": false; }; "closed": { "alias": "closed"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "template": { "alias": "template"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; }; }, { "beforeexpand": "beforeexpand"; "beforecollapse": "beforecollapse"; "expand": "expand"; "collapse": "collapse"; "afterexpand": "afterexpand"; "aftercollapse": "aftercollapse"; "selected": "selected"; "deselected": "deselected"; }, never, ["*"], true, never>;
}

declare class SohoCardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoCardModule, never, [typeof SohoCardsComponent, typeof SohoCardActionableComponent, typeof SohoCardHeaderComponent, typeof SohoCardContentComponent, typeof SohoCardPaneComponent, typeof SohoCardComponent], [typeof SohoCardsComponent, typeof SohoCardActionableComponent, typeof SohoCardHeaderComponent, typeof SohoCardContentComponent, typeof SohoCardPaneComponent, typeof SohoCardComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoCardModule>;
}

declare class SohoChartComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    set chartOptions(chartOptions: SohoChartOptions);
    set selectedIndex(index: number);
    set dataSet(dataset: SohoDataSet);
    set type(type: ChartTypes);
    set axisLabels(axisLabels: AxisLabels);
    set showLegend(showLegend: boolean);
    set hideLabels(hideLabels: boolean);
    set formatterString(formatterString: string);
    set legendFormatter(legendFormatter: string);
    set chartLabel(chartLabel: ChartLabel);
    set chartredrawOnResizeLabel(redrawOnResize: boolean);
    set chartAnimate(animate: boolean);
    selected: EventEmitter<ChartEvent>;
    unselected: EventEmitter<ChartEvent>;
    rendered: EventEmitter<ChartEvent>;
    /**
     * @todo replace override of native attribute
     */
    contextmenu: EventEmitter<ChartEvent>;
    private _chartOptions;
    private jQueryElement?;
    private chart?;
    private updateRequired;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    getChartOptions(): SohoChartOptions;
    updated(): void;
    getSelected(): any;
    setSelectRef(ref: any): void;
    setSelectDataIndex(selectIndex: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoChartComponent, "div[soho-chart]", never, { "chartOptions": { "alias": "chartOptions"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; "dataSet": { "alias": "dataSet"; "required": false; }; "type": { "alias": "type"; "required": false; }; "axisLabels": { "alias": "axisLabels"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "hideLabels": { "alias": "hideLabels"; "required": false; }; "formatterString": { "alias": "formatterString"; "required": false; }; "legendFormatter": { "alias": "legendFormatter"; "required": false; }; "chartLabel": { "alias": "chartLabel"; "required": false; }; "chartredrawOnResizeLabel": { "alias": "chartredrawOnResizeLabel"; "required": false; }; "chartAnimate": { "alias": "chartAnimate"; "required": false; }; }, { "selected": "selected"; "unselected": "unselected"; "rendered": "rendered"; "contextmenu": "contextmenu"; }, never, never, true, never>;
}

declare class SohoChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoChartModule, never, [typeof SohoChartComponent], [typeof SohoChartComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoChartModule>;
}

/**
 * Wrapper for soho checkboxes.
 *
 * Note the control must have type="checkbox" for the values to be passed
 * to and from any ng model instances.
 */
declare class SohoCheckBoxComponent implements AfterViewInit, OnDestroy {
    private elementRef;
    private ngZone;
    /**
     * Indicate that the checkbox is partial
     */
    partial?: boolean;
    /**
     * Indicate that the checkbox is displayed as a switch.
     */
    switch: boolean;
    /**
     * Bind attributes to the host input element
     */
    get isCheckBoxType(): string;
    get isCheckBox(): boolean;
    get isPartialCheckBox(): boolean;
    get isPartialAriaChecked(): "mixed" | null;
    get isSwitch(): boolean;
    checked?: boolean;
    /** Called when the checkbox value changes. */
    changeEvent: EventEmitter<SohoCheckBoxEvent>;
    /** Called when the checkbox updates in some way. */
    updateEvent: EventEmitter<SohoCheckBoxEvent>;
    /**
     * Local variables
     */
    private jQueryElement?;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching the component's selector.
     */
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCheckBoxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCheckBoxComponent, "[soho-checkbox]", never, { "partial": { "alias": "partial"; "required": false; }; "switch": { "alias": "switch"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "changeEvent": "changeEvent"; "updateEvent": "updateEvent"; }, never, ["*"], true, never>;
}

declare class SohoCheckBoxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCheckBoxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoCheckBoxModule, never, [typeof SohoCheckBoxComponent], [typeof SohoCheckBoxComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoCheckBoxModule>;
}

declare class SohoCirclepagerComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private settings;
    get isCirclePager(): boolean;
    /** The number of slides to show in one view / pane. */
    set slidesToShow(value: number);
    /** First showing slide/group, an 0-based integer */
    set startingSlide(value: number);
    /** Setting loop: true will loop back after next/previous reached to end */
    set loop(value: boolean);
    private jQueryElement?;
    private circlepager?;
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCirclepagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoCirclepagerComponent, "[soho-circlepager]", never, { "slidesToShow": { "alias": "slidesToShow"; "required": false; }; "startingSlide": { "alias": "startingSlide"; "required": false; }; "loop": { "alias": "loop"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoCirclepagerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoCirclepagerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoCirclepagerModule, never, [typeof SohoCirclepagerComponent], [typeof SohoCirclepagerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoCirclepagerModule>;
}

declare class SohoColorPickerComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    ngControl: NgControl;
    ref: ChangeDetectorRef;
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    /** Value Accessor */
    private valueAccessor?;
    /**
     * Local variables
     */
    private jQueryElement;
    private colorpicker;
    private isEditable?;
    isUppercase?: boolean;
    isClearable?: boolean;
    private isDisabled?;
    private isReadOnly?;
    private isShowLabel?;
    isColorOnly?: boolean;
    hasCustomColor?: boolean;
    clearableTextString: string;
    private options?;
    /**
     * Indicates the color list
     */
    set colors(colors: Array<SohoColorOption> | undefined);
    /**
     * Enables or disables the control
     */
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    /**
     * Enables or disables editing
     */
    set editable(value: boolean | undefined);
    get editable(): boolean | undefined;
    /**
     * Enables or disables forces upper case hex.
     */
    set uppercase(value: boolean);
    /**
     * Enables or disables the clear option.
     */
    set clearable(value: boolean);
    /**
     * Enables or disables the clear option.
     */
    set customColors(value: boolean);
    /**
     * Enables or disables the colorOnly option.
     */
    set colorOnly(value: boolean);
    /**
     * Sets the clearableText option.
     */
    set clearableText(value: string);
    /**
     * Add extra attributes like id's to the component
     */
    set attributes(value: Array<Object> | Object);
    /**
     * Sets the control to readonly
     */
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    /**
     * Sets the control to show color label
     */
    set showLabel(value: boolean | undefined);
    get showLabel(): boolean | undefined;
    /**
     * Called when the colorpicker value changes
     *
     * @todo replace override of native attribute
     */
    change: EventEmitter<SohoColorPickerEvent>;
    /**
     * Called when the colorpicker updates in some way.
     */
    updatedEvent: EventEmitter<JQuery.TriggeredEvent>;
    /**
     * Public API
     */
    getLabelValue(): any;
    getHexValue(): any;
    /**
     * Bind attributes to the host input element
     */
    get isColorpicker(): boolean;
    /**
     * Creates an instance of SohoColorPickerComponent.
     *
     * @param element the element this component encapsulates.
     * @param ngZone the angualar zone for this component
     * @param ngControl any associated form control (optional)
     *
     */
    constructor(element: ElementRef, ngZone: NgZone, ngControl: NgControl, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Event handler for the 'changed' event on the 'colorpicker' component.
     *
     *
     * @param event the standard jQuery event.
     */
    private onChanged;
    /**
     * In case options are being bound asynchronously, you will need to trigger updated on
     * soho colorpicker control so it updates its value labels.
     */
    updated(): SohoColorPickerComponent;
    onUpdated(event: JQuery.TriggeredEvent): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    ngOnDestroy(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoColorPickerComponent, [null, null, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoColorPickerComponent, "input[soho-colorpicker]", never, { "colors": { "alias": "colors"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "uppercase": { "alias": "uppercase"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "customColors": { "alias": "customColors"; "required": false; }; "colorOnly": { "alias": "colorOnly"; "required": false; }; "clearableText": { "alias": "clearableText"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; }, { "change": "change"; "updatedEvent": "updated"; }, never, ["*"], true, never>;
}

declare class SohoColorPickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoColorPickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoColorPickerModule, never, [typeof SohoColorPickerComponent], [typeof SohoColorPickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoColorPickerModule>;
}

declare class SohoColumnComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isColumn(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any>);
    /** Chart Type */
    set type(value: SohoColumnType);
    /** Default is a single or stacked chart. */
    set isStacked(value: boolean);
    /** If false the legend will not be shown. */
    set showLegend(value: boolean);
    /** true|false - will do or not do the animation, 'initial' will do only first time the animation. */
    set animate(value: boolean);
    /** If true, the component will not resize when resizing the page. */
    set redrawOnResize(value: boolean);
    /** The d3 axis format. */
    set format(value: string);
    set formatterString(value: string);
    /** Settings for the chart ticks. Can set ticks: {format: d3Format, number: n} */
    set ticks(value: object);
    /** An empty message will be displayed when there is no chart data. */
    set emptyMessage(value: SohoEmptyMessageOptions);
    /** Settings for the chart xAxis. */
    set xAxis(value: object);
    /** Settings for the chart yAxis. */
    set yAxis(value: object);
    /** Settings for the chart tooltip. */
    set tooltip(tooltip: string | SohoColumnTooltipFunction);
    /**
     * Add extra attributes like id's to the component
     */
    set attributes(attributes: Array<Object> | Object);
    /**
     * Add extra options to control axisLabels
     */
    set axisLabels(value: any);
    /**
     * Add option to control/adjust the data group bar stacked position.
     */
    set stackedTransformX(value: number);
    /**
     * Adds the ability to use line chart if set to true. This will need a target value to the dataset.
     */
    set hideDots(value: boolean);
    set useLine(value: boolean);
    /** Forces decimal point to '.' on y-axis ticks regardless of locale. */
    set forceDecimalPoint(value: boolean);
    /** Events */
    selected: EventEmitter<SohoColumnSelectEvent>;
    unselected: EventEmitter<SohoColumnSelectEvent>;
    rendered: EventEmitter<Object>;
    dblclick: EventEmitter<Object>;
    /**
     * @todo replace override of native attribute
     */
    contextmenu: EventEmitter<Object>;
    private jQueryElement?;
    column?: SohoColumn | null;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    updated(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    setSelected(selected: SohoColumnSelected): void;
    toggleSelected(selected: SohoColumnSelected): void;
    getSelected(): Object | Object[] | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoColumnComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoColumnComponent, "[soho-column]", never, { "dataset": { "alias": "dataset"; "required": false; }; "type": { "alias": "type"; "required": false; }; "isStacked": { "alias": "isStacked"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "format": { "alias": "format"; "required": false; }; "formatterString": { "alias": "formatterString"; "required": false; }; "ticks": { "alias": "ticks"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "axisLabels": { "alias": "axisLabels"; "required": false; }; "stackedTransformX": { "alias": "stackedTransformX"; "required": false; }; "hideDots": { "alias": "hideDots"; "required": false; }; "useLine": { "alias": "useLine"; "required": false; }; "forceDecimalPoint": { "alias": "forceDecimalPoint"; "required": false; }; }, { "selected": "selected"; "unselected": "unselected"; "rendered": "rendered"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoColumnModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoColumnModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoColumnModule, never, [typeof SohoColumnComponent], [typeof SohoColumnComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoColumnModule>;
}

/**
 * SUB COMPONENT: SOHO-CONTEXT-MENU-HEADING
 */
declare class SohoContextMenuHeadingComponent {
    get isHeading(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoContextMenuHeadingComponent, "li[soho-context-menu-heading]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-CONTEXT-MENU-SHORTCUT-TEXT
 */
declare class SohoContextMenuShortCutTextComponent {
    get isShortCutText(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuShortCutTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoContextMenuShortCutTextComponent, "span[soho-context-menu-shortcut-text]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-CONTEXT-MENU-SEPARATOR
 */
declare class SohoContextMenuSeparatorComponent {
    get isSeparator(): boolean;
    singleSelectableSection: boolean;
    multiSelectableSection: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuSeparatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoContextMenuSeparatorComponent, "li[soho-context-menu-separator]", never, { "singleSelectableSection": { "alias": "singleSelectableSection"; "required": false; }; "multiSelectableSection": { "alias": "multiSelectableSection"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-CONTEXT-MENU-LABEL
 */
declare class SohoContextMenuItemLabelComponent {
    get hrefAttr(): string;
    menuId?: string;
    menuUrl?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuItemLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoContextMenuItemLabelComponent, "a[soho-context-menu-label]", never, { "menuId": { "alias": "menuId"; "required": false; }; "menuUrl": { "alias": "menuUrl"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-CONTEXT-MENU-ITEM
 */
declare class SohoContextMenuItemComponent {
    isChecked?: boolean;
    isSelectable: boolean;
    isDisabled: boolean;
    isIndented: boolean;
    subMenu: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoContextMenuItemComponent, "li[soho-context-menu-item]", never, { "isChecked": { "alias": "isChecked"; "required": false; }; "isSelectable": { "alias": "isSelectable"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isIndented": { "alias": "isIndented"; "required": false; }; "subMenu": { "alias": "subMenu"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * MAIN DIRECTIVE: SOHO-CONTEXT-MENU
 */
declare class SohoContextMenuDirective implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    private jQueryElement?;
    private contextMenu?;
    private options;
    selected: EventEmitter<SohoContextMenuEvent>;
    beforeopen: EventEmitter<SohoContextMenuEvent>;
    /**
     * @todo replace override of native attribute
     */
    open: EventEmitter<SohoContextMenuEvent>;
    closeEvent: EventEmitter<SohoContextMenuEvent>;
    set trigger(trigger: SohoPopupMenuTrigger);
    set menu(menu: string);
    /** Auto Focus */
    set autoFocus(autoFocus: boolean);
    get autoFocus(): boolean;
    /** Mouse focus. */
    set mouseFocus(mouseFocus: boolean);
    get mouseFocus(): boolean;
    /** Attach to body. */
    set attachToBody(attachToBody: boolean);
    get attachToBody(): boolean;
    set placementOpts(placementOpts: SohoPopupmenuPlacementOpts);
    get placementOpts(): SohoPopupmenuPlacementOpts;
    set offset(offset: SohoPopupmenuOffset);
    get offset(): SohoPopupmenuOffset;
    listOffset: SohoPopupmenuOffset;
    set removeOnDestroy(removeOnDestroy: boolean);
    get removeOnDestroy(): boolean;
    /** beforeOpen - ajax callback for open event */
    set beforeOpen(beforeOpen: SohoPopupMenuSourceFunction);
    get beforeOpen(): SohoPopupMenuSourceFunction;
    /** beforeOpen - ajax callback for open event */
    lazyLoad: boolean;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    private init;
    onContextMenu(e: JQuery.TriggeredEvent, api: any): void;
    updated(): void;
    teardown(): void;
    /**
     * Closes the popup menu
     *
     * @param isCancelled Internally set option used if the operation is a cancel.
     *  Wont matter for manual api call.
     * @param noFocus Do not return focus to the calling element (fx a button)
     */
    close(isCancelled?: boolean, noFocus?: boolean): void;
    ngOnDestroy(): void;
    initializeComponent(eventObj?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoContextMenuDirective, "[soho-context-menu]", never, { "trigger": { "alias": "trigger"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "mouseFocus": { "alias": "mouseFocus"; "required": false; }; "attachToBody": { "alias": "attachToBody"; "required": false; }; "placementOpts": { "alias": "placementOpts"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "listOffset": { "alias": "listOffset"; "required": false; }; "removeOnDestroy": { "alias": "removeOnDestroy"; "required": false; }; "beforeOpen": { "alias": "beforeOpen"; "required": false; }; "lazyLoad": { "alias": "lazyLoad"; "required": false; }; }, { "selected": "selected"; "beforeopen": "beforeopen"; "open": "open"; "closeEvent": "close"; }, never, never, true, never>;
}

declare class SohoContextMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoContextMenuModule, never, [typeof SohoContextMenuDirective, typeof SohoContextMenuHeadingComponent, typeof SohoContextMenuShortCutTextComponent, typeof SohoContextMenuItemComponent, typeof SohoContextMenuItemLabelComponent, typeof SohoContextMenuSeparatorComponent], [typeof SohoContextMenuDirective, typeof SohoContextMenuHeadingComponent, typeof SohoContextMenuShortCutTextComponent, typeof SohoContextMenuItemComponent, typeof SohoContextMenuItemLabelComponent, typeof SohoContextMenuSeparatorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoContextMenuModule>;
}

declare class SohoContextualActionPanelModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextualActionPanelModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoContextualActionPanelModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoContextualActionPanelModule>;
}

/**
 * Wrapper for the jQuery panel control.
 *
 */
declare class SohoContextualActionPanelRef<T> {
    private appRef;
    private injector;
    private ngZone;
    /** Component - if the content is derived from an existing component. */
    private componentRef?;
    /** Selector referencing the panel-panel after it has been moved to the panel container. */
    private jQueryElement?;
    /** Soho Control Api */
    private contextualactionpanel?;
    /** The result of the panel. */
    private _panelResult;
    /** Event fired when the panel is opened. */
    private open$;
    /** Event fired when the panel is closed. */
    private close$;
    /** Event fired before closing the panel */
    private beforeClose$;
    /** Event fired after closing the panel. */
    private afterClose$;
    /** Event fired before opening the panel. */
    private beforeOpen$;
    /** Event fired after opening the panel. */
    private afterOpen$;
    /** Handle resource tidy up of this class. */
    private destroyed$;
    /**
     * The component displayed as the panel content.
     *
     * @param componentRef - reference to the component defining the panel panel content.
     */
    set component(componentRef: ComponentRef<T>);
    /**
     * The component displayed inside the panel's frame, if specified.  This may
     * be null if the component is built from an HTML fragment or a jQuery selector.
     */
    get componentPanel(): T | null;
    /**
     * The buttonset API for the CAP dialog.
     *
     * @returns the buttonset API for the CAP dialog, if initialized.
     */
    get buttonsetAPI(): SohoButtonsetStatic | undefined;
    /**
     * The toolbar API for the CAP dialog.
     *
     * @returns the toolbar API for the CAP dialog, if initialized.
     */
    get toolbarAPI(): SohoToolbarStatic | SohoToolbarFlexStatic | undefined;
    /**
     * Cached options.
     */
    private _options;
    /**
     * Sets the whole options block for this contextual action panel.
     *
     * @param options - the options to set.
     */
    options(options: SohoContextualActionPanelOptions): SohoContextualActionPanelRef<T>;
    /**
     * Sets the whole options block for this contextual action panel.
     *
     * @param modalSettings - the options to set.
     */
    modalSettings(modalSettings: SohoModalOptions): SohoContextualActionPanelRef<T>;
    /**
     * Ability to add class(es) to the parent CAP element.
     *
     * @param cssClass - the class(es) value to add in CAP element.
     */
    cssClass(cssClass: string): this;
    /** Add extra attributes like id's to the component **/
    attributes(attributes: Array<Object> | Object): SohoContextualActionPanelRef<T>;
    /**
     * Sets the title of the panel.
     *
     * @param title - the title of the panel.
     */
    title(title: string): SohoContextualActionPanelRef<T>;
    /**
     * Sets the id of the detail element that will be used to display the detail content.
     *
     * @param detailRefId - the id of the content.
     */
    detailRefId(detailRefId?: string | undefined): SohoContextualActionPanelRef<T>;
    /**
     * Sets the buttons to use on the panel panel.
     *
     * @deprecated (use modalSettings)
     * @param buttons - list of buttons to display
     */
    buttons(buttons: SohoContextualActionPanelButton[]): SohoContextualActionPanelRef<T>;
    /**
     * Sets the 'id' that the panel control uses.
     *
     * @deprecated (use modalSettings)
     * @param id - the id.
     */
    id(id: string): SohoContextualActionPanelRef<T>;
    /**
     * Sets the 'id' that the panel control uses.
     *
     * @param initializeContent - Sets the ability to initialize content.
     */
    initializeContent(initializeContent: boolean): SohoContextualActionPanelRef<T>;
    /**
     * Sets the 'centerTitle' that the panel control uses.
     *
     * @deprecated (use modalSettings)
     * @param centerTitle - Aligns title to center
     */
    centerTitle(centerTitle: boolean): SohoContextualActionPanelRef<T>;
    /**
     * Sets the `noSaveButton` to remove the save button in the toolbar.
     * @param noSaveButton - if true, remove the save button
     */
    noSaveButton(noSaveButton: boolean): SohoContextualActionPanelRef<T>;
    /**
     * Sets the 'trigger' that the panel control uses.
     *
     * @deprecated (use modalSettings)
     * @param trigger - when to open the panel.
     */
    trigger(trigger: SohoContextualActionPanelTriggerType): SohoContextualActionPanelRef<T>;
    /**
     * Sets the 'content' that the panel control uses.
     *
     * @param content - a selector or string representing the panel content.
     */
    content(content: JQuery | string): SohoContextualActionPanelRef<T>;
    /**
     * Applies a function to the instantiated component,
     * allowing the component to be modified, or initialised.
     *
     * The function is provided with a typed value for the
     * instance.
     *
     * @param component - the instantiated instance.
     * @return the panel ref for onward assignment.
     */
    apply(fn: (component: T) => void): SohoContextualActionPanelRef<T>;
    /**
     * panel result property.
     *
     * @param panelResult - the stored result of the panel.
     */
    set panelResult(panelResult: any);
    get panelResult(): any;
    /**
     * Constructor.
     */
    constructor(appRef: ApplicationRef, componentFactoryResolver: ComponentFactoryResolver, injector: Injector, ngZone: NgZone, settings: SohoContextualActionPanelOptions, panelComponent?: PanelComponentType<T>);
    /**
     * Opens the panel.
     *
     * @return the panel ref.
     */
    open(): SohoContextualActionPanelRef<T>;
    /**
     * Closes the panel, if open. The panel is not closed
     * fully until the 'afterClosed' event is fired.
     *
     * @param panelResult - optional result - passed back to the caller.
     * @param doForce - optional - forces the modal to close.
     */
    close(panelResult?: any, doForce?: boolean): SohoContextualActionPanelRef<T>;
    /**
     * Opened Event.
     *
     * This event is fired when the panel is being opened.
     *
     * @param eventFn - the function to invoke when the panel is to be opened.
     */
    opened(eventFn: Function): SohoContextualActionPanelRef<T> | null;
    /**
     * Opened Event.
     * This event is fired after the panel has been opened.
     *
     * @param eventFn - the function to invoke when the panel is to be opened.
     */
    afterOpen(eventFn: Function): SohoContextualActionPanelRef<T> | null;
    /**
     * Opened Event.
     * This event is fired after the panel has been opened.
     *
     * @param eventFn - the function to invoke when the panel is to be opened.
     */
    beforeOpen(eventFn: Function): SohoContextualActionPanelRef<T> | null;
    /**
     * Before Closed Event.
     * This event is fired before closing the panel.
     *
     * @param eventFn - the function to invoke when the panel before closing.
     */
    beforeClose(eventFn: Function): SohoContextualActionPanelRef<T> | null;
    /**
     * Closed Event.
     *
     * This event is fired when the panel is being closed.
     *
     * @param eventFn - the function to invoke when the panel is to be closed.
     */
    closed(eventFn: SohoContextualActionPanelEventFunction<T>): SohoContextualActionPanelRef<T> | null;
    /**
     * After Closed Event.
     *
     * This event is fired, with the result of the panel, when the panel has been
     * closed and destroyed.
     *
     * @param eventFn - the function to invoke after the panel has been closed.
     */
    afterClose(eventFn: SohoContextualActionPanelEventFunction<T> | null): SohoContextualActionPanelRef<T> | null;
    /**
     * Handles the 'open' event, fired just before
     * the focus is assigned to a panel.
     *
     * @param event - full event object.
     */
    private onOpen;
    /**
     * Handles the 'afterOpen' event, fired after the panel panel
     * has been opened.
     *
     * @param event - full event object.
     */
    private onAfterOpen;
    /**
     * Handles the 'afterOpen' event, fired after the panel panel
     * has been opened.
     *
     * @param event - full event object.
     */
    private onBeforeOpen;
    /**
     * Handles the close event.
     *
     * @param event - full event object.
     * @param isCancelled - is true if the cancel button was pressed; otherwise false.
     */
    private onClose;
    /**
     * Handles the 'afterClose' event, fired when th panel
     * has been closed and tidy up is required.
     *
     * @param event - full event object.
     */
    private onAfterClose;
    /**
     * Handles the 'beforeclose' event.
     *
     * @param event - full event object.
     */
    private onBeforeClose;
}
/**
 * Close/AfterClose event handler.
 *
 * @param result - the panel result (if set); may be undefined.
 * @param panelRef - the panel reference (or wrapper); never null.
 * @param panelComponent - the component hosted in the modal; may be undefined.
 */
type SohoContextualActionPanelEventFunction<T> = (result: any, panelRef: SohoContextualActionPanelRef<T>, panelComponent: T) => void;
/**
 * Contract for all SohoContextualActionPanelComponents.
 */
interface SohoContextualActionPanelComponent<T> {
}

/**
 * This service is used to create a panel panel, based on the content
 * of an Angular Component on the screen.
 */
declare class SohoContextualActionPanelService {
    private readonly appRef;
    private readonly componentFactoryResolver;
    private readonly injector;
    private readonly ngZone;
    /**
     * Constructor.
     *
     * @param appRef - application reference; must not be null.
     * @param componentFactoryResolver - used to create component factories for components dynamically.
     * @param injector - the current in scope injector, use as a delegate.
     * @param ngZone - the angular zone; must not be null.
     */
    constructor(appRef: ApplicationRef, componentFactoryResolver: ComponentFactoryResolver, injector: Injector, ngZone: NgZone);
    /**
     * Creates a panel defined by the given component, returning a reference to the
     * panel that can be interacted with.
     *
     * The component has the potential to include the panel reference when it is
     * instantiated, as a provider.
     *
     * The panel won't necessarily be open yet, see the panel ref Api for further methods.
     *
     * @param component - the type of the component to instantiate; must not be null.
     * @param _parent - The parent container; obsolete but parameter kept for backwards API compatibility. Has no effect.
     * @param options - the default options for the panel; optional.
     *
     * @return the panel reference.
     */
    contextualactionpanel<T>(component: PanelComponentType<T>, _parent?: ViewContainerRef, options?: SohoContextualActionPanelOptions): SohoContextualActionPanelRef<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoContextualActionPanelService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoContextualActionPanelService>;
}
/**
 * Object with a "new"" method returning the type T.
 */
type PanelComponentType<T> = new (...args: any[]) => T;

/**
 * Dynamic Soho Data Grid Service contract.
 */
declare abstract class SohoDataGridService {
    /**
     * Returns the columns to use for the data grid.
     */
    abstract getColumns(): SohoDataGridColumn[];
    /**
     * Returns a list of data rows.
     *
     * @todo implement pagingpaging
     *
     * @param gridRequest -used to define the data to return.
     */
    abstract getData(req: SohoDataGridSourceRequest | undefined | null): Observable<any[]>;
}

type SohoDataGridType = 'auto' | 'content-only';
/**
 * Contract for cell editors.
 */
interface ExtendedSohoDataGridCellEditor extends SohoDataGridCellEditor {
    component: Type<SohoDataGridCellEditor>;
    args: SohoDataGridEditCellFunctionArgs;
    input?: JQuery<HTMLElement>;
    useValue: boolean;
    className?: string;
    /**
     * Initialise the edit control with the given component.  The control
     * mist conform to the SohoDataGridCellEditor contract.
     */
    init(componentRef: ComponentRef<SohoDataGridCellEditor>): void;
    /**
     * Destroy the editor.
     */
    destroy(): void;
}
declare class SohoAngularEditorAdapter implements ExtendedSohoDataGridCellEditor {
    component: Type<SohoDataGridCellEditor>;
    args: SohoDataGridEditCellFunctionArgs;
    componentRef?: ComponentRef<SohoDataGridCellEditor> | null;
    input?: JQuery<HTMLElement>;
    useValue: boolean;
    className?: string;
    constructor(component: Type<SohoDataGridCellEditor>, args: SohoDataGridEditCellFunctionArgs);
    init(componentRef: ComponentRef<SohoDataGridCellEditor>): void;
    val(value?: any): any;
    focus(): void;
    destroy(): void;
}
/**
 * Angular Wrapper for the Soho Data Grid Component.
 *
 * This component searches for an element with the attribute
 * 'soho-datagrid' in the parent's DOM tree, initialising it with
 * the Soho datagrid control.
 *
 * The data is provided either by a component input or an implementation
 * of the DataGridService interface, by specifying an implementation
 * on the hosting component, i.e.
 *
 * providers: [ provide: DataGridService, useClass: DataGridDemoService} ]
 */
declare class SohoDataGridComponent implements OnInit, AfterViewInit, OnDestroy, AfterViewChecked {
    private ngZone;
    private elementRef;
    private changeDetector;
    private resolver;
    private injector;
    private app;
    protected datagridService: SohoDataGridService;
    static AUTO: SohoDataGridType;
    static CONTENT_ONLY: SohoDataGridType;
    /**
     * Sets the grid options for the data grid, marking this components
     * as requiring a full rebuild at the end of the change lifecycle.
     *
     * @param gridOptions - not null grid options.
     */
    set gridOptions(gridOptions: SohoDataGridOptions);
    get gridOptions(): SohoDataGridOptions;
    /**
     * Defines which property in the data rows is to be used as the id of each
     * row of the data.
     *
     * @param idProperty string id
     */
    set idProperty(idProperty: string | undefined);
    get idProperty(): string | undefined;
    /**
     * If true, shows an icon next to ellipsis text to indicate more content.
     *
     * @param ellipsisWithIcon boolean
     */
    set ellipsisWithIcon(ellipsisWithIcon: boolean | undefined);
    get ellipsisWithIcon(): boolean | undefined;
    /**
     * Sets the aria label for the datagrid table element
     * @param ariaLabel string
     */
    set ariaLabel(ariaLabel: string | undefined);
    get ariaLabel(): string | undefined;
    /**
     * The value of the frozenColumns option - returns the requested
     * value if the control has not been created yet.
     */
    get frozenColumns(): SohoDataGridFrozenColumns | undefined;
    /**
     * Sets the frozenColumns settings - will force a grid rebuild if the component has already been
     * created.
     *
     * @param frozenColumns - the frozenColumns settings.
     */
    set frozenColumns(frozenColumns: SohoDataGridFrozenColumns | undefined);
    /**
     * If true allows
     */
    set cellNavigation(cellNavigation: boolean | undefined);
    get cellNavigation(): boolean | undefined;
    get isVerticalScrollToEnd(): boolean | undefined;
    /**
     * Changes the row navigation setting of the data grid. If rowNavigation
     * is "false” then a border is not displayed around the row.
     *
     * Defaults to true.
     *
     * @param rowlNavigation i "false” then grid will NOT show a border around the row.
     */
    set rowNavigation(rowNavigation: boolean | undefined);
    get rowNavigation(): boolean | undefined;
    /**
     * If true, displays the rows in the grid using alternate shading, otherwise
     * all the rows use the same shading.
     */
    set alternateRowShading(alternateRowShading: boolean | undefined);
    get alternateRowShading(): boolean | undefined;
    /**
     * The data to be displayed provided as an array
     * of json objects compatible with the column meta
     * data provided.
     *
     * @param dataset - array of json objects
     */
    set dataset(dataset: Array<any> | undefined);
    /**
     * Return the dataset currently displayed by the datagrid.
     *
     * @return an array of objects.
     */
    get dataset(): any[] | undefined;
    /**
     * If true the columns can be reorders; otherwise if false they are fixed.
     */
    set columnReorder(columnReorder: boolean | undefined);
    get columnReorder(): boolean | undefined;
    set disableClientSort(disableClientSort: boolean | undefined);
    get disableClientSort(): boolean | undefined;
    set allowTriStateSort(allowTriStateSort: boolean | undefined);
    get allowTriStateSort(): boolean | undefined;
    set disableClientFilter(disableClientFilter: boolean | undefined);
    get disableClientFilter(): boolean | undefined;
    set resultsText(resultsText: SohoDataGridResultsTextFunction);
    set showFilterTotal(showFilterTotal: boolean | undefined);
    get showFilterTotal(): boolean | undefined;
    /**
     * If true, the grid allows edits, otherwise if false edits are disabled.
     */
    set editable(editable: boolean | undefined);
    get editable(): boolean | undefined;
    /**
     * Input that defines a function which is used to determine if a row is disabled, or not.
     */
    set isRowDisabled(isRowDisabled: SohoIsRowDisabledFunction | undefined);
    get isRowDisabled(): SohoIsRowDisabledFunction | undefined;
    set allowOneExpandedRow(allowOneExpandedRow: boolean | undefined);
    get allowOneExpandedRow(): boolean | undefined;
    set rowTemplate(rowTemplate: string | undefined);
    get rowTemplate(): string | undefined;
    set rowTemplateComponent(rowTemplateComponent: any);
    get rowTemplateComponent(): any;
    set rowTemplateComponentInputs(rowTemplateComponentInputs: any);
    get rowTemplateComponentInputs(): any;
    set rowTemplateField(rowTemplateField: string | undefined);
    get rowTemplateField(): string | undefined;
    /**
     * If true, will select the cell text soon as entering edit mode
     */
    set selectOnEdit(selectOnEdit: boolean | undefined);
    get selectOnEdit(): boolean | undefined;
    set isList(isList: boolean | undefined);
    get isList(): boolean | undefined;
    set menuId(menuId: any);
    /** beforeOpen - ajax callback for open event */
    set menuBeforeOpen(menuBeforeOpen: SohoPopupMenuSourceFunction);
    get menuBeforeOpen(): SohoPopupMenuSourceFunction;
    /**
     * Sets the row height for the grid, to be one of the supported options.
     *
     * @param rowHeight - 'extra-small' | 'small' | 'medium' | 'large'
     */
    set rowHeight(rowHeight: SohoDataGridRowHeight);
    /**
     * Sets the height of the row to something other then the three built in rowHeights.
     *
     * @param fixedRowHeight Any integer
     */
    set fixedRowHeight(fixedRowHeight: number | string | Function);
    /**
     * Whether selection is enabled.
     *
     * @param selectable valid values are: 'multiple', 'single', 'mixed', 'siblings' and false.
     */
    set selectable(selectable: any);
    get selectable(): any;
    set showSelectAllCheckBox(showSelectAllCheckBox: boolean | undefined);
    get showSelectAllCheckBox(): boolean | undefined;
    set clickToSelect(clickToSelect: boolean | undefined);
    get clickToSelect(): boolean | undefined;
    set toolbar(toolbar: SohoToolbarOptions);
    set initializeToolbar(initializeToolbar: boolean | undefined);
    get initializeToolbar(): boolean | undefined;
    set saveUserSettings(settingsForSave: SohoDataGridSaveUserSettings);
    set paging(paging: boolean | undefined);
    get paging(): boolean | undefined;
    set pagesize(pagesize: number);
    set pagesizes(pagesizes: Array<number>);
    set indeterminate(indeterminate: boolean);
    set actionableMode(actionableMode: boolean | undefined);
    get actionableMode(): boolean | undefined;
    set saveColumns(saveColumns: boolean);
    /**
     * Input for the source function.
     *
     * @param source the dataset's source function.
     */
    set source(source: SohoDataGridSourceFunction | undefined);
    /**
     * Enables or disables the filter bar on the grid.
     *
     * @param filterable if true, the filter bar is displayed; otherwise no filter bar is displayed.
     */
    set filterable(filterable: boolean | undefined);
    get filterable(): boolean | undefined;
    set filterWhenTyping(filterWhenTyping: boolean | undefined);
    get filterWhenTyping(): boolean | undefined;
    /**
     * If true the datagrid is displayed as a tree, otherwise
     * the grid is displayed as flat rows.
     *
     * This field is dynamic, and will cause the grid to be rebuilt
     * if changed.
     *
     * @param treeGrid - boolean flag indicating if the data is hierarchical.
     */
    set treeGrid(treeGrid: boolean | undefined);
    get treeGrid(): boolean | undefined;
    /**
     * Returns the unqiue identifier; which may be undefined.
     */
    get uniqueId(): string | undefined;
    /**
     * Sets the unqiueId - will force a grid rebuild if the component has already been
     * created.
     *
     * @param unqiueId - the new id.
     */
    set uniqueId(uniqueId: string | undefined);
    /**
     * The value of the rowReorder flag - returns the requested value if the control has not been created yet.
     */
    get rowReorder(): boolean | undefined;
    /**
     * Sets the rowReorder flag - will force a grid rebuild if the component has already been
     * created.
     *
     * @param rowReorder - if true the rows will be reorderable; otherwise they will not.
     */
    set rowReorder(value: boolean | undefined);
    /**
     * The value of the showDirty flag - returns the requested value if the control has not been created yet.
     */
    get showDirty(): boolean | undefined;
    /**
     * Sets the showDirty flag - will force a grid rebuild if the component has already been
     * created.
     *
     * @param showDirty - if true then dirty rows will be highlighted; otherwise they will not.
     */
    set showDirty(value: boolean | undefined);
    /**
     * The value of the addCellLayoutClass flag.
     */
    get addCellLayoutClass(): boolean | undefined;
    /**
     * Sets the addCellLayoutClass flag - If set false, will remove datagrid-cell-layout class from expandable rows.
     * created.
     *
     * @param addCellLayoutClass - if true then dirty rows will be highlighted; otherwise they will not.
     */
    set addCellLayoutClass(value: boolean | undefined);
    /**
     * Sets the resizeMode option to changes the column resize behavior.
     *
     * @param resizeMode - if true then dirty rows will be highlighted; otherwise they will not.
     */
    set resizeMode(value: SohoDataGridResizeMode | undefined);
    /**
     * Sets the datagrid header background color, either dark or light.
     * @param headerBackgroundColor - default value is 'dark'
     */
    set headerBackgroundColor(value: SohoDatagridHeaderBackgroundColor | undefined);
    set headerMenuId(value: string | undefined);
    get headerMenuId(): string | undefined;
    set headerMenuSelected(headerMenuSelected: Function);
    set headerMenuBeforeOpen(headerMenuBeforeOpen: Function);
    get disableRowDeactivation(): boolean | undefined;
    set disableRowDeactivation(value: boolean | undefined);
    get disableRowDeselection(): boolean | undefined;
    set disableRowDeselection(value: boolean | undefined);
    /**
     * Used to hold an object that can be referenced in formatters
     * and editors or anywhere else a datagrid reference is available
     */
    set userObject(userObject: any | undefined);
    get userObject(): any | undefined;
    /**
     * The value of the groupable option - returns the requested
     * value if the control has not been created yet.
     */
    get groupable(): SohoDataGridGroupable | undefined;
    /**
     * Sets the groupable settings - will force a grid rebuild if the component has already been
     * created.
     *
     * @param groupable - the groupable settings.
     */
    set groupable(value: SohoDataGridGroupable | undefined);
    /**
     * The array of data to display in the grid.
     *
     * @param an array of objects matching the column definition.
     *
     * As this method can be called before the control is
     * initialised, stash the data for later, and only
     * call loadData on the control api if ready.
     */
    set data(data: any[] | undefined);
    /**
     * The array of columns to display in the grid.
     *
     * As this method can be called before the control is
     * initialised, stash the data for later, and only
     * call loadData on the control api if ready.
     */
    set columns(columns: SohoDataGridColumn[] | undefined);
    /**
     *
     * Summary row columns settingss
     */
    set summaryRowColumns(summaryRowColumns: SohoDataGridSummaryRowColumnSettings[]);
    /**
     * If true an extra column will be added to the end that fills the space.
     * This allows columns to not stretch to fill so they are a constant size.
     * This setting cannot be used with percent columns.
     */
    set spacerColumn(spacerColumn: boolean | undefined);
    /**
     * If true an extra column is currently added to the end that fills the space.
     */
    get spacerColumn(): boolean | undefined;
    set sizeColumnsEqually(sizeColumnsEqually: boolean | undefined);
    get sizeColumnsEqually(): boolean | undefined;
    set expandableRow(expandableRow: boolean | undefined);
    get expandableRow(): boolean | undefined;
    set redrawOnResize(redrawOnResize: boolean | undefined);
    get redrawOnResize(): boolean | undefined;
    set exportConvertNegative(exportConvertNegative: boolean | undefined);
    get exportConvertNegative(): boolean | undefined;
    set overrideTabbing(overrideTabbing: boolean | undefined);
    get overrideTabbing(): boolean | undefined;
    set headerTabStops(headerTabStops: boolean | null | undefined);
    get headerTabStops(): boolean | null | undefined;
    set suppressNonInteractiveFocus(suppressNonInteractiveFocus: boolean | undefined);
    get suppressNonInteractiveFocus(): boolean | undefined;
    set showEditorIcons(showEditorIcons: boolean | undefined);
    get showEditorIcons(): boolean | undefined;
    set stickyHeader(stickyHeader: boolean);
    set attributes(attributes: Array<Object> | Object);
    /**
     * Determines the sizing method for the auto sizing columns.
     */
    set columnSizing(columnSizing: 'both' | 'data' | 'header' | undefined);
    /**
     * Determines the sizing method for the auto sizing columns.
     */
    get columnSizing(): 'both' | 'data' | 'header' | undefined;
    /**
     * The name of the column stretched to fill the width of the datagrid,
     * or 'last' where the last column will be stretched to fill the
     * remaining space.
     *
     * @param stretchColumn - the name of the column to stretch; or 'last',
     */
    set stretchColumn(stretchColumn: string | undefined);
    /**
     * The name of the column to stretch, or 'last' if the
     * last column is stretched.
     */
    get stretchColumn(): string | undefined;
    /**
     * If true, column will recalculate its width and stretch if required on column change.
     *
     * @param stretchColumnOnChange - If false stretch logic wont run on column change.
     */
    set stretchColumnOnChange(stretchColumnOnChange: boolean | undefined);
    /**
     * The current value of stretchColumnOnChange.
     */
    get stretchColumnOnChange(): boolean | undefined;
    /**
     * Whether to show the page size selector or not.
     */
    set showPageSizeSelector(showPageSizeSelector: boolean);
    /**
     * If true, hides the pager if there's only one page worth of results.
     */
    set hidePagerOnOnePage(hidePagerOnOnePage: boolean);
    /**
     * The column groups
     *
     * As this method can be called before the control is
     * initialised, stash the data for later, and only
     * call loadData on the control api if ready.
     */
    set columnGroup(columnGroups: SohoDataGridColumnGroup[]);
    get columnGroup(): SohoDataGridColumnGroup[];
    /**
     * The `emptyMessage` data grid option.
     * Use null or undefined to remove any empty message.
     */
    set emptyMessage(emptyMessage: SohoEmptyMessageOptions | null | undefined);
    get emptyMessage(): SohoEmptyMessageOptions | null | undefined;
    /**
     * Enable toolips on the cell values, at a cost of performance.
     */
    set enableTooltips(value: boolean | undefined);
    get enableTooltips(): boolean | undefined;
    set selectChildren(selectChildren: boolean | undefined);
    get selectChildren(): boolean | undefined;
    set allowChildExpandOnMatch(allowChildExpandOnMatch: boolean | undefined);
    get allowChildExpandOnMatch(): boolean | undefined;
    /**
     * Defines the source type of the grid, either:
     *
     * - "content-only" where table elements are provided in the body.
     * - "auto" where columns and rows are obtained for an
     *   injected service (if defined) or via the Inputs if not.
     *
     * Allow the input to be overriden, to match the component selector.
     */
    set sohoDatagrid(datagridType: SohoDataGridType | '' | undefined | null);
    selected: EventEmitter<SohoDataGridSelectedEvent>;
    deselected: EventEmitter<SohoDataGridDeselectedEvent>;
    cellchange: EventEmitter<SohoDataGridCellChangeEvent>;
    rowRemove: EventEmitter<SohoDataGridRowRemoveEvent>;
    rowAdd: EventEmitter<SohoDataGridAddRowEvent>;
    filtered: EventEmitter<SohoDataGridFilteredEvent>;
    expandrow: EventEmitter<SohoDataGridToggleRowEvent>;
    /**
     * This event is fired when a key is pressed
     *
     * @todo remove override of native attribute
     */
    keydown: EventEmitter<SohoDataGridKeyDownEvent>;
    exiteditmode: EventEmitter<SohoDataGridEditModeEvent>;
    beforeentereditmode: EventEmitter<SohoDataGridEditModeEvent>;
    /**
     * This event is fired when edit mode is entered.
     */
    entereditmode: EventEmitter<SohoDataGridEditModeEvent>;
    collapserow: EventEmitter<SohoDataGridToggleRowEvent>;
    sorted: EventEmitter<SohoDataGridSortedEvent>;
    searched: EventEmitter<any[]>;
    nextPage: EventEmitter<SohoPagerPagingInfo>;
    previousPage: EventEmitter<SohoPagerPagingInfo>;
    firstPage: EventEmitter<SohoPagerPagingInfo>;
    lastPage: EventEmitter<SohoPagerPagingInfo>;
    pageSizeChange: EventEmitter<SohoPagerPagingInfo>;
    beforePaging: EventEmitter<SohoPagerPagingInfo>;
    afterPaging: EventEmitter<SohoPagerPagingInfo>;
    beforeRowActivated: EventEmitter<SohoDataGridRowActivated>;
    rowActivated: EventEmitter<SohoDataGridRowActivated>;
    columnChange: EventEmitter<SohoDataGridColumnChange>;
    rowDeactivated: EventEmitter<SohoDataGridRowActivated>;
    rowClicked: EventEmitter<SohoDataGridRowClicked>;
    rowDoubleClicked: EventEmitter<SohoDataGridRowClicked>;
    contextMenu: EventEmitter<SohoDataGridRowClicked>;
    rowReordered: EventEmitter<SohoDataGridRowReorderedEvent>;
    openFilterRow: EventEmitter<SohoDataGridOpenFilterRowEvent>;
    closeFilterRow: EventEmitter<SohoDataGridCloseFilterRowEvent>;
    settingsChanged: EventEmitter<SohoDataGridSettingsChangedEvent>;
    rendered: EventEmitter<SohoDataGridRenderedEvent>;
    afterRender: EventEmitter<SohoDataGridAfterRenderEvent>;
    verticalScroll: EventEmitter<SohoDataGridScrollEvent>;
    filteroperatorchanged: EventEmitter<SohoDataGridFilterOperatorChangedEvent>;
    isDisabled: boolean;
    /**
     * Sets the role for the grid.
     */
    get datagridRole(): "treegrid" | "datagrid";
    private jQueryElement?;
    private datagrid?;
    private gridData?;
    private datagridType?;
    private _gridOptions;
    private refreshHint;
    private changedOptions;
    private cellComponents;
    private rowTemplateComponents;
    /**
     * Constructor.
     *
     * @param ngZone - the angular zone for this component.
     * @param elementRef - the element matching the component's selector.
     * @param changeDetector - the component's change detector.
     * @param resolver - component factory resolver (for editors/formatters).
     * @param injector - dynamic component injector (for editors/formatters).
     * @param datagridService - service for obtaining data (optional)
     */
    constructor(ngZone: NgZone, elementRef: ElementRef, changeDetector: ChangeDetectorRef, resolver: ComponentFactoryResolver, injector: Injector, app: ApplicationRef, datagridService: SohoDataGridService);
    getColumnGroup(idx: number): string;
    getColumnById(idx: number): string;
    /**
     * Overrides the sort function used by the datagrid,
     * can only be used once the grid has been created.
     *
     * @todo this should made lazy.
     */
    setSortFunction(sortFunction: SohoDataGridSortFunction): void;
    /**
     * Sets the column and direction to sort the dataset on.
     *
     * Can only be used once the grid has been initialised, otherwise
     * an error is thrown.
     *
     * @param columnId the id of the column to sort on; must be non-null.
     * @param ascending if true sort ascending, otherwise descending.  If not supplied the setting is toggled.
     */
    setSortColumn(columnId: string, ascending?: boolean): void;
    /**
     * Used to set the sort indicator on a column when disableClientSort is set to true.
     */
    setSortIndicator(columnId: string, ascending: boolean | undefined | null): void;
    pageSize(): number | undefined;
    updatePagingInfo(pageInfo: SohoPagerPagingInfo): void;
    enable(): void;
    disable(): void;
    updateRow(idx: number, row: any): void;
    hideColumn(id: any): void;
    showColumn(id: any): void;
    columnById(id: string): Array<any>;
    getColumns(): Array<any>;
    getColumnGroups(): SohoDataGridColumnGroup[];
    /** Get the column index from the col's id */
    columnIdxById(columnId: string): number;
    getHeaderRowColumn(fld: any): any;
    /**
     * Adds a row of data to the datagrid at the given optional location.
     *
     * @param data the row of data to add.
     * @param location the optional location, 'top' or 'bottom' or a number.
     */
    addRow(data: any, location?: 'top' | 'bottom' | number): void;
    /**
     * Adds multiple rows of data to the datagrid at the given optional location.
     * @param data Array of data to add.
     * @param location the optional location, 'top' or 'bottom' or a number.
     */
    addRows(data: any[], location?: 'top' | 'bottom' | number): void;
    /**
     * Removes a row matching the rowIndex passed in from the data and grid.
     *
     * @param rowIndex the index of the row to remove.
     */
    removeRow(rowIndex: number, noSync?: boolean, noTrigger?: boolean): void;
    /**
     * Returns an array of the dirty rows in the grid.
     *
     * @return an array of the dirty rows in the grid.
     */
    dirtyRows(): Array<any>;
    /**
     * Returns an array of the dirty cells in the grid.
     *
     * @return an array of the dirty cells in the grid.
     */
    dirtyCells(): Array<any>;
    /**
     * Clear all dirty cells.
     */
    clearDirty(): void;
    /**
     * Commit the cell that's currently in edit mode.
     */
    commitCellEdit(): void;
    /**
     * Clear all dirty cells in given row.
     *
     * @param row - the row number (idx) of the row.
     */
    clearDirtyRow(row: number): void;
    /**
     * Clear dirty on given cell.
     *
     * @param row - the row number (idx) of the row
     * @param cell - the cell number (idx) of the cell
     */
    clearDirtyCell(row: number, cell: number): void;
    /**
     * Clear all error for a given cell in a row
     *
     * @param row The row index.
     * @param cell The cell index.
     */
    clearAllCellError(row: number, cell: number): void;
    /**
     * Clear a cell with an error of a given type
     *
     * @param row The row index.
     * @param cell The cell index.
     * @param type of error.
     */
    clearCellError(row: number, cell: number, type: any): void;
    /**
     * Clear a row level all errors, alerts, info messages
     *
     * @param row The row index.
     */
    clearRowError(row: number): void;
    /**
     * Clear all errors, alerts and info messages in entire datagrid.
     */
    clearAllErrors(): void;
    /** Validate all rows and cells in the entire grid if they have validation on the column */
    showRowError(row: number, message: string, type: SohoAlertType): void;
    /** Validate all cells in a specific row */
    validateRow(row: number): void;
    /**
     * Set and show a message/error on the given row.
     */
    validateAll(): void;
    /**
     * Sets the status of a given row in the grid.
     *
     * @param idx - the row number (idx) of the row
     * @param status - status class name e.g. 'error'
     * @param tooltip - string value for tooltip message e.g. 'Error'
     */
    rowStatus(idx: number, status: string, tooltip: string): void;
    /**
     * Return an array containing all of the currently modified rows, the type of modification
     * and the cells that are dirty and the data.
     *
     * @returns An keyed object showing the dirty row info.
     */
    getModifiedRows(): SohoDataGridModifiedRows;
    /**
     * Set a cell to dirty and add the dirty icon visually.
     *
     * @param row The row index
     * @param cell The cell index
     * @param toggle True to set it and false to remove it
     * @param data Adds dirty data to the internal tracker
     */
    setDirtyIndicator(row: number, cell: number, toggle: boolean, data?: object): void;
    /**
     * Removes all selected rows
     */
    removeSelected(): void;
    /**
     * Toggles the display of the filter row.
     */
    toggleFilterRow(): void;
    /**
     * Accept conditions from outside or pull from filter row
     */
    applyFilter(conditions?: Array<SohoDataGridFilterCondition>): void;
    /**
     * Set the filter row from passed data / settings
     */
    setFilterConditions(conditions: Array<SohoDataGridFilterCondition>): void;
    /**
     * Get filter conditions in array form from the UI
     */
    filterConditions(): Array<SohoDataGridFilterCondition>;
    /**
     * Clears any filter defined, for this datagrid.
     */
    clearFilter(): void;
    /**
     * Hides the contextual toolbar.
     */
    hideContextualToolbar(): void;
    /**
     * Returns the rows currently selected on the data grid.
     *
     * @return an array of SohoDataGridSelectedRow instances.
     * @deprecated use selectedRows instead.
     */
    getSelectedRows(): SohoDataGridSelectedRow[];
    /**
     * Returns the rows currently selected on the data grid.
     *
     * @return an array of SohoDataGridSelectedRow instances.
     */
    selectedRows(): SohoDataGridSelectedRow[];
    /**
     * Selects all the rows in the grid.
     */
    selectAllRows(): void;
    /**
     * Unselects all the rows in the grid.
     */
    unSelectAllRows(): void;
    /**
     * Sets the selected status of the specified row in the data grid.
     *
     * @param idx - the row number (idx) of the row to select.
     * @deprecated - use selectRows instead.
     */
    selectRow(idx: number): void;
    /**
     * Deselects the specified row in the data grid.
     *
     * @param idx - the row number (idx) of the row to deselect.
     */
    unselectRow(idx: number): void;
    /**
     * Selects a range of rows based on the provided row indexes.
     *
     * @param start - the start index
     * @param end - then end index
     */
    selectRange(start: number, end: number): void;
    /**
     * Set the selected rows by passing the row index or an array of row indexes
     */
    selectRows(row: number | number[]): void;
    /**
     * Set the status of the checkbox on the header.
     *
     * @param state 'all', 'partial' or 'all'.
     */
    setHeaderCheckboxState(state: SohoDataGridHeaderCheckboxState): void;
    /**
     * Activate the row of the passed-in idx.
     * NOTE: valid only when selection mode is 'mixed'
     */
    activateRow(idx: number): void;
    /**
     * Deactivate the currently activated row.
     *
     * NOTE: valid only when selection mode is 'mixed'
     */
    deactivateRow(): void;
    /**
     * Get the currently activated row.
     * NOTE: valid only when selection mode is 'mixed'
     */
    activatedRow(): SohoDataGridRowActivated;
    /**
     * Sets the active cell.
     *
     * @param rowIndex The index of the row of the cell to set active.
     * @param cellNumber The index of the cell to set active.
     * @param nodeFocus If true, will focus on cell even if offscreen.
     */
    setActiveCell(rowIndex: number, cellNumber: number, nodeFocus?: boolean): void;
    /**
     * Gets the active cell info
     */
    getActiveCell(): any;
    /**
     * Scrolls the row at <b>idx</b> into view in the view port.
     *
     * @param idx The index of the row to scroll into view.
     */
    scrollRowIntoView(idx: number): void;
    /**
     * Returns an array of row numbers for the rows containing the value for the specified field.
     *
     * @param fieldName The field name to search.
     * @param value The value to use in search.
     */
    findRowsByValue(fieldName: string, value: any): number[];
    /**
     * Programmatically trigger a call to the datagrid.settings.source
     * function with the given pagerType.
     *
     * @param pagerType - a valid pager type.
     */
    triggerSource(pagerType: SohoDataGridTriggerSourcePagerType, callback?: Function): void;
    /**
     * Trigger export of grid data to Excel.
     *
     * @param fileName The prefix name to be used for the exported file.
     * @param worksheetName The name to be used for the worksheet.
     * @param customDs A datasource to override the default (deprecated)
     */
    exportToExcel(fileName: string, worksheetName?: string | undefined, customDs?: Object[]): void;
    /**
     * Trigger export of grid data to CSV formatted file.
     *
     * @param fileName The prefix name to be used for the exported file.
     * @param customDs A datasource to override the default.
     * @param separator The separator to use in the cvs file, defaults to 'sep=,'
     * @param format if true, date and number values will be formatted based on the locale
     */
    exportToCsv(fileName: string, customDs?: Object[], separator?: object | string, format?: boolean): void;
    /**
     * Trigger export of grid data to Excel format.
     *
     * @param fileName The prefix name to be used for the exported file.
     * @param keepGridFormatting Whether to keep grid formatting (defaults to true)
     */
    exportToXlsx(fileName: string, keepGridFormatting?: boolean): void;
    /**
     * Updates the columns and columnGroups displayed on the grid.
     *
     * @param columns The datagrid columns to update.
     * @param columnGroups The column groups to update.
     */
    updateColumns(columns: SohoDataGridColumn[], columnGroups: SohoDataGridColumnGroup[]): void;
    /**
     * Parse a JSON array with columns and return the column object.
     *
     * @param columnStr The json represntation of the column object.
     * @return  The array of columns.
     */
    columnsFromString(columns: string): Object;
    /**
     * Reset columns to their defaults (used on restore menu item).
     */
    resetColumns(): void;
    /**
     * Open the personalize dialog.
     */
    personalizeColumns(): void;
    /**
     * Restore the user settings from local Storage or as passed in.
     *
     * @param settings The object containing the settings to use.
     */
    restoreUserSettings(settings: any): void;
    /**
     * Search a term across all columns and highlight it
     * @param term - the search term
     */
    keywordSearch(value: string): void;
    /**
     * Handle a request to load the data for the grid from the service.
     *
     * @todo paging - not yet fully implemented?
     */
    private onDataRequest;
    /**
     * Event fired after a child row has been expanded.
     */
    private onExpandRowHandler;
    /**
     * Build component for rowTemplate
     */
    private buildRowTemplateComponent;
    /**
     * Event fired after a context menu is opened
     */
    private onKeyDownHandler;
    /**
     * Event fired after a child row has been expanded.
     *
     * @param idProperty string id
     */
    set onBeforeSelect(beforeSelectFunction: SohoDataGridBeforeSelectFunction | undefined);
    get onBeforeSelect(): SohoDataGridBeforeSelectFunction | undefined;
    /**
     *  Makes it possible to save selections when changing pages on server side paging.
     *  You may want to also use showSelectAllCheckBox: false
     */
    set allowSelectAcrossPages(allowSelectAcrossPages: boolean | undefined);
    get allowSelectAcrossPages(): boolean | undefined;
    /**
     *  Select all will effect only on current page and its for client side paging only.
     */
    set selectAllCurrentPage(selectAllCurrentPage: boolean | undefined);
    get selectAllCurrentPage(): boolean | undefined;
    /**
     * An array of column IDs used to define aria descriptors for selection checkboxes.
     */
    set columnIds(columnIds: Array<String | Number> | undefined);
    get columnIds(): Array<String | Number> | undefined;
    /**
     *If true, the new row indicator will display after adding a row
     *
     * @param showNewRowIndicator boolean show new indicator setting
     */
    set showNewRowIndicator(showNewRowIndicator: boolean | undefined);
    get showNewRowIndicator(): boolean | undefined;
    set onExpandChildren(expandChildrenFunction: SohoDataGridExpandChildrenFunction | undefined);
    get onExpandChildren(): SohoDataGridExpandChildrenFunction | undefined;
    set onCollapseChildren(collapseChildrenFunction: SohoDataGridCollapseChildrenFunction | undefined);
    get onCollapseChildren(): SohoDataGridCollapseChildrenFunction | undefined;
    set onPostRenderCell(onPostRenderCell: SohoDataGridPostRenderCellFunction);
    set onDestroyCell(onDestroyCell: SohoDataGridPostRenderCellFunction);
    set onEditCell(onEditCell: SohoDataGridEditCellFunction);
    set onKeyDown(onKeyDown: SohoDataGridKeyDownFunction);
    set onExpandRow(onExpandRow: SohoDataGridExpandRowFunction);
    set fallbackImage(fallbackImage: string | undefined);
    get fallbackImage(): string | undefined;
    set fallbackTooltip(fallbackTooltip: SohoFallbackTooltipOptions | undefined);
    get fallbackTooltip(): SohoFallbackTooltipOptions | undefined;
    /**
     * Event fired after edit mode is activated on an editor.
     *
     * @param args the event arguments
     */
    private onExitEditMode;
    /**
     * Event fired before edit mode is activated on an editor.
     *
     * @param args the event arguments
     */
    private onBeforeEnterEditMode;
    /**
     * Event fired when edit mode is activated on an editor.
     *
     * @param args the event arguments
     */
    private onEnterEditMode;
    /**
     * Event fired after a child row has been collapsed.
     */
    private onCollapseRow;
    /**
     * Event fired when a row has been added.
     */
    private onRowAdd;
    /**
     * Event fired when a cell has changed.
     */
    private onCellChange;
    /**
     * Event fired when a row has been clicked.
     */
    private onRowClicked;
    /**
     * Event fired when the filter row is closed.
     */
    private onCloseFilterRow;
    /**
     * Event fired when a context menu is is clicked.
     */
    private onContextMenu;
    /**
     * Event fired when a context menu is is clicked.
     */
    private onDoubleClick;
    /**
     * Event fired when the data is filtered.
     */
    private onFiltered;
    /**
     * Event fired when filter row opened.
     */
    private onOpenFilterRow;
    /**
     * Event fired when a row is removed.
     */
    private onRowRemove;
    /**
     * Event fired when the data is rendered
     */
    private onRendered;
    /**
     * Event fired when the data is filtered.
     */
    private onAfterRender;
    /**
     * Event fired before a row is activated.
     */
    private onBeforeRowActivated;
    /**
     * Event fired when a row is activated.
     */
    private onRowActivated;
    private onColumnChange;
    /**
     * Event fired when a row is deactivated.
     */
    private onRowDeactivated;
    /**
     * Event fired when a row is reordered.
     */
    private onRowReordered;
    /**
     * Event fired when a row is selected or deselected.
     */
    private onSelected;
    /**
     * Event fired when rows are deselected.
     */
    private onDeselected;
    /**
     * Event fired when settings are changed on the grid.
     */
    private onSettingsChanged;
    /**
     * Event fired when the data is sorted.
     */
    private onSorted;
    /**
     * Event fired when search in toolbar is triggered
     * @param args Searched data
     */
    private onSearched;
    /**
     * Event fired when using built-in pager to next page.
     */
    private onNextPage;
    /**
       * Event fired when using built-in pager to previous page.
       */
    private onPreviousPage;
    /**
       * Event fired when using built-in pager to first page.
       */
    private onFirstPage;
    /**
       * Event fired when using built-in pager to last page.
       */
    private onLastPage;
    /**
     * Event fired on paging size change
     */
    private onPageSizeChange;
    /**
     * Event fired before paging
     */
    private onBeforePaging;
    /**
     * Event fired after paging
     */
    private onAfterPaging;
    /**
     * Event fired after vertical scroll
     */
    private onVerticalScroll;
    /**
     * Event fired after vertical scroll
     */
    private onFilterOperatorChanged;
    /**
     * Returns the row dom jQuery node.
     *
     * @param  row The row index.
     * @param  includeGroups If true groups are taken into account.
     * @return The dom jQuery node
     */
    rowNode(row: number, includeGroups: boolean): any;
    /**
     * Returns the cell dom node.
     *
     * @param  row The row index.
     * @param  cell The cell index.
     * @param  includeGroups If true groups are taken into account.
     * @return The dom node
     */
    cellNode(row: number, cell: number, includeGroups: boolean): any;
    /**
     * Expand Detail Row Or Tree Row
     * @param {number} dataRowIndex The row to toggle
     * @param  {boolean} expandOnly Set the toggle to expand only
     */
    toggleRowDetail(dataRowIndex: number, expandOnly?: boolean | undefined): void;
    updateSummaryRow(col: object, cell: number): void;
    /**
     * Initialize the component after Angular initializes the data-bound input properties.
     */
    ngOnInit(): void;
    /**
     * Called after Angular projects external content into its view.
     */
    ngAfterViewInit(): void;
    /**
     *
     */
    ngAfterViewChecked(): void;
    /**
     * Cleanup just before Angular destroys the component.
     *
     * Unsubscribe observables, detach event handlers and remove other resources to avoid memory leaks.
     */
    ngOnDestroy(): void;
    /**
     * Destroys the jQuery control (and any other resources)
     * associated with this component.
     */
    private destroyDataGrid;
    /**
     * Handles the 'postCellRender' event.
     *
     * @param container the container to host the element.
     * @param args the formatter arguments.
     */
    private onPostRenderCellHandler;
    /**
     * Handles the 'destroyCell' event.
     *
     * @param container the container.
     * @param args the args
     */
    private onDestroyCellHandler;
    private onEditCellHandler;
    private buildDataGrid;
    /**
     * Marks the components as requiring a rebuild after the next update.
     *
     * @todo possible add hints? Rebuild, Update, SetOption
     *
     * @param optionName - the option that was updated, (allowing specific handling)
     * @param hint - the type of refresh required, update?.
     */
    private markForRefresh;
    /**
     * Stop gap method to update the current datagrid and rebuild it again.
     *
     * This is required whilst there is no method found that can update the view
     * for a particular input.
     */
    updated(settings?: SohoDataGridOptions): void;
    /**
     * Update the dataset of datagrid
     * @param dataset New dataset to be used
     * @param pagerInfo Pager info if needed
     */
    updateDataset(dataset: Array<any>, pagerInfo?: object | undefined): void;
    /**
     * Updates the source setting/function to use source input if set.
     * Otherwise use dataGridService if that is set.
     *
     * @param source the function
     */
    private updateSource;
    private checkForComponentEditors;
    private checkForSummaryRowSettings;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDataGridComponent, [null, null, null, null, null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoDataGridComponent, "[soho-datagrid]", never, { "gridOptions": { "alias": "gridOptions"; "required": false; }; "idProperty": { "alias": "idProperty"; "required": false; }; "ellipsisWithIcon": { "alias": "ellipsisWithIcon"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "frozenColumns": { "alias": "frozenColumns"; "required": false; }; "cellNavigation": { "alias": "cellNavigation"; "required": false; }; "rowNavigation": { "alias": "rowNavigation"; "required": false; }; "alternateRowShading": { "alias": "alternateRowShading"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "columnReorder": { "alias": "columnReorder"; "required": false; }; "disableClientSort": { "alias": "disableClientSort"; "required": false; }; "allowTriStateSort": { "alias": "allowTriStateSort"; "required": false; }; "disableClientFilter": { "alias": "disableClientFilter"; "required": false; }; "resultsText": { "alias": "resultsText"; "required": false; }; "showFilterTotal": { "alias": "showFilterTotal"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "isRowDisabled": { "alias": "isRowDisabled"; "required": false; }; "allowOneExpandedRow": { "alias": "allowOneExpandedRow"; "required": false; }; "rowTemplate": { "alias": "rowTemplate"; "required": false; }; "rowTemplateComponent": { "alias": "rowTemplateComponent"; "required": false; }; "rowTemplateComponentInputs": { "alias": "rowTemplateComponentInputs"; "required": false; }; "rowTemplateField": { "alias": "rowTemplateField"; "required": false; }; "selectOnEdit": { "alias": "selectOnEdit"; "required": false; }; "isList": { "alias": "isList"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; "menuBeforeOpen": { "alias": "menuBeforeOpen"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "fixedRowHeight": { "alias": "fixedRowHeight"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "showSelectAllCheckBox": { "alias": "showSelectAllCheckBox"; "required": false; }; "clickToSelect": { "alias": "clickToSelect"; "required": false; }; "toolbar": { "alias": "toolbar"; "required": false; }; "initializeToolbar": { "alias": "initializeToolbar"; "required": false; }; "saveUserSettings": { "alias": "saveUserSettings"; "required": false; }; "paging": { "alias": "paging"; "required": false; }; "pagesize": { "alias": "pagesize"; "required": false; }; "pagesizes": { "alias": "pagesizes"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "actionableMode": { "alias": "actionableMode"; "required": false; }; "saveColumns": { "alias": "saveColumns"; "required": false; }; "source": { "alias": "source"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "filterWhenTyping": { "alias": "filterWhenTyping"; "required": false; }; "treeGrid": { "alias": "treeGrid"; "required": false; }; "uniqueId": { "alias": "uniqueId"; "required": false; }; "rowReorder": { "alias": "rowReorder"; "required": false; }; "showDirty": { "alias": "showDirty"; "required": false; }; "addCellLayoutClass": { "alias": "addCellLayoutClass"; "required": false; }; "resizeMode": { "alias": "resizeMode"; "required": false; }; "headerBackgroundColor": { "alias": "headerBackgroundColor"; "required": false; }; "headerMenuId": { "alias": "headerMenuId"; "required": false; }; "headerMenuSelected": { "alias": "headerMenuSelected"; "required": false; }; "headerMenuBeforeOpen": { "alias": "headerMenuBeforeOpen"; "required": false; }; "disableRowDeactivation": { "alias": "disableRowDeactivation"; "required": false; }; "disableRowDeselection": { "alias": "disableRowDeselection"; "required": false; }; "userObject": { "alias": "userObject"; "required": false; }; "groupable": { "alias": "groupable"; "required": false; }; "data": { "alias": "data"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "summaryRowColumns": { "alias": "summaryRowColumns"; "required": false; }; "spacerColumn": { "alias": "spacerColumn"; "required": false; }; "sizeColumnsEqually": { "alias": "sizeColumnsEqually"; "required": false; }; "expandableRow": { "alias": "expandableRow"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "exportConvertNegative": { "alias": "exportConvertNegative"; "required": false; }; "overrideTabbing": { "alias": "overrideTabbing"; "required": false; }; "headerTabStops": { "alias": "headerTabStops"; "required": false; }; "suppressNonInteractiveFocus": { "alias": "suppressNonInteractiveFocus"; "required": false; }; "showEditorIcons": { "alias": "showEditorIcons"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "columnSizing": { "alias": "columnSizing"; "required": false; }; "stretchColumn": { "alias": "stretchColumn"; "required": false; }; "stretchColumnOnChange": { "alias": "stretchColumnOnChange"; "required": false; }; "showPageSizeSelector": { "alias": "showPageSizeSelector"; "required": false; }; "hidePagerOnOnePage": { "alias": "hidePagerOnOnePage"; "required": false; }; "columnGroup": { "alias": "columnGroup"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "enableTooltips": { "alias": "enableTooltips"; "required": false; }; "selectChildren": { "alias": "selectChildren"; "required": false; }; "allowChildExpandOnMatch": { "alias": "allowChildExpandOnMatch"; "required": false; }; "sohoDatagrid": { "alias": "soho-datagrid"; "required": false; }; "onBeforeSelect": { "alias": "onBeforeSelect"; "required": false; }; "allowSelectAcrossPages": { "alias": "allowSelectAcrossPages"; "required": false; }; "selectAllCurrentPage": { "alias": "selectAllCurrentPage"; "required": false; }; "columnIds": { "alias": "columnIds"; "required": false; }; "showNewRowIndicator": { "alias": "showNewRowIndicator"; "required": false; }; "onExpandChildren": { "alias": "onExpandChildren"; "required": false; }; "onCollapseChildren": { "alias": "onCollapseChildren"; "required": false; }; "onPostRenderCell": { "alias": "onPostRenderCell"; "required": false; }; "onDestroyCell": { "alias": "onDestroyCell"; "required": false; }; "onEditCell": { "alias": "onEditCell"; "required": false; }; "onKeyDown": { "alias": "onKeyDown"; "required": false; }; "onExpandRow": { "alias": "onExpandRow"; "required": false; }; "fallbackImage": { "alias": "fallbackImage"; "required": false; }; "fallbackTooltip": { "alias": "fallbackTooltip"; "required": false; }; }, { "selected": "selected"; "deselected": "deselected"; "cellchange": "cellchange"; "rowRemove": "rowRemove"; "rowAdd": "rowAdd"; "filtered": "filtered"; "expandrow": "expandrow"; "keydown": "keydown"; "exiteditmode": "exiteditmode"; "beforeentereditmode": "beforeentereditmode"; "entereditmode": "entereditmode"; "collapserow": "collapserow"; "sorted": "sorted"; "searched": "searched"; "nextPage": "nextPage"; "previousPage": "previousPage"; "firstPage": "firstPage"; "lastPage": "lastPage"; "pageSizeChange": "pageSizeChange"; "beforePaging": "beforePaging"; "afterPaging": "afterPaging"; "beforeRowActivated": "beforeRowActivated"; "rowActivated": "rowActivated"; "columnChange": "columnChange"; "rowDeactivated": "rowDeactivated"; "rowClicked": "rowClicked"; "rowDoubleClicked": "rowDoubleClicked"; "contextMenu": "contextMenu"; "rowReordered": "rowReordered"; "openFilterRow": "openFilterRow"; "closeFilterRow": "closeFilterRow"; "settingsChanged": "settingsChanged"; "rendered": "rendered"; "afterRender": "afterRender"; "verticalScroll": "verticalScroll"; "filteroperatorchanged": "filteroperatorchanged"; }, never, ["*"], true, never>;
}
/**
 * Details of the 'expandrow' and 'collapserow' events.
 */
interface SohoDataGridToggleRowEvent extends SohoDataGridRowExpandEvent {
    grid: SohoDataGridComponent;
    args?: any;
}
/**
 * Details of the 'keydown' event
 */
interface SohoDataGridKeyDownEvent {
    e: JQuery.Event;
    args?: SohoDataGridKeyDownArgs;
    response?: Function;
}

declare class SohoDataGridModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDataGridModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoDataGridModule, never, [typeof SohoDataGridComponent], [typeof SohoDataGridComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoDataGridModule>;
}

declare class SohoDatePickerComponent extends BaseControlValueAccessor<string | number | string[] | Date | undefined> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    ref: ChangeDetectorRef;
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    /**
     * Local variables
     */
    private jQueryElement?;
    private datepicker?;
    private isDisabled?;
    private isReadOnly?;
    private _options;
    private updateLegend;
    private _validation;
    /**
     * Indicates to display the timepicker; defaults to false.
     */
    set showTime(showTime: boolean);
    /**
     * If true current time will be used for the time portion otherwise 12:00 midnight is used.
     */
    set useCurrentTime(useCurrentTime: boolean);
    /**
     * Indicates the pattern for the time format.
     */
    set timeFormat(timeFormat: string);
    /**
     * An integer from 1 to 60; multiples of this value are displayed as options in the minutes dropdown.
     */
    set minuteInterval(minuteInterval: number);
    /**
     * An integer from 1 to 60; multiples of this value are displayed as options in the seconds dropdown.
     */
    set secondInterval(secondInterval: number);
    /**
     * Change the datepickers first day of the week.
     * An integer from 0 - 6 where 0 = Sunday, 1 = Monday, etc...
     */
    set firstDayOfWeek(firstDayOfWeek: SohoDatePickerDayOfWeek);
    /**
     * If true the field will be sized to the width of the date.
     */
    set autoSize(autoSize: boolean);
    /**
     * Show the today button on the header.
     */
    set showToday(showToday: boolean);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /**
     * Indicates mode, either 'standard' or 'range'.
     */
    set mode(mode: SohoDatePickerMode);
    /**
     * Use range of two dates options.
     */
    set range(range: SohoDatePickerRange);
    /**
     * If a non-matching minutes value is entered, will round the minutes value to the nearest interval on the blur event.
     */
    set roundToInterval(roundToInterval: boolean);
    /**
     * Indicates the pattern for the date format or the value of 'locale'.
     */
    set dateFormat(dateFormat: string);
    /**
     * Indicates a placeholder for an empty value; defaults to false.
     */
    set placeholder(placeholder: string);
    /**
     * Indicates an object containing a date or range of dates that are enabled or disabled.
     */
    set disable(disable: any);
    /**
     * Indicates a legend is shown to associate dates
     */
    set showLegend(showLegend: boolean);
    /**
     * Indicates if the month and year will render as dropdowns.
     */
    set showMonthYearPicker(showMonthYearPicker: boolean);
    /**
     * Indicates if the month and year will render as dropdowns.
     */
    set showWeekNumber(showWeekNumber: boolean);
    /**
     * Indicates if the days portion of the calendar will be hidden.
     */
    set hideDays(hideDays: boolean);
    /**
     * The number of years ahead to show in the month/year picker should total 9 with yearsBack.
     */
    set yearsAhead(yearsAhead: number);
    /**
     * The number of years back to show in the month/year picker should total 9 with yearsAhead.
     */
    set yearsBack(yearsBack: number);
    /**
     * Options for how the legend displays
     */
    set legend(legend: Array<SohoDatePickerLegend>);
    /**
     * The name of the locale to use for this instance. If not set, the current locale will be used.
     */
    set locale(locale: string);
    /**
     * Calendar's name. Currently just 'gregorian' or 'islamic-umalqura'
     */
    set calendarName(calendarName: SohoDatePickerCalendarName);
    /**
     * Indicates if the dates will use UTC format
     */
    set useUTC(useUTC: boolean);
    /**
     * Set the input to tabbable
     */
    set tabbable(tabbable: boolean);
    /**
     * Set the input to allow increment/decrement using keyboard
     */
    set incrementWithKeyboard(incrementWithKeyboard: boolean);
    /**
     * Set the input to allow today using keyboard
     */
    set todayWithKeyboard(todayWithKeyboard: boolean);
    /**
     * If false, the user cannot type into the datepicker field and must
     * select a date exclusively from the calendar popup. Defaults to true.
     */
    set editable(editable: boolean);
    get editable(): boolean | undefined;
    /**
     * Sets the options for the date picker
     */
    set options(options: SohoDatePickerOptions);
    set validation(validation: SohoDatePickerValidator);
    get options(): SohoDatePickerOptions;
    /**
     * Enables or disables the control
     */
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    /**
     * Sets the control to readonly
     */
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    /**
     * Called when the datepicker value changes
     *
     * @todo replace override of native attribute
     */
    change: EventEmitter<SohoDatePickerEvent>;
    /**
     * Called when the datepicker is closed.
     */
    listclosed: EventEmitter<any>;
    /**
     * Called when the datepicker is opened.
     */
    listopened: EventEmitter<any>;
    /**
     * Called before a month will be rendered in the datepicker
     */
    beforemonthrendered: EventEmitter<any>;
    /**
     * Called after a month has been rendered in the datepicker
     */
    monthrendered: EventEmitter<SohoDatePickerMonthRenderedEvent>;
    /**
     * Public API
     */
    setValue(value: string | Date | number | string[], trigger: boolean, isTime: boolean): void;
    getValue(asDate?: boolean): string | Date | number | string[];
    focus(): void;
    openCalendar(): void;
    /**
     * Bind attributes to the host input element
     */
    get isDatepicker(): boolean;
    get isTimepicker(): boolean;
    /**
     * Creates an instance of SohoDatePickerComponent.
     *
     * @param element the element this component encapsulates.
     * @param ngZone the angular zone for this component.
     * @param ref reference to the change detector
     */
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Handle the control being changed.
     */
    onChange(event: SohoDatePickerEvent): void;
    /**
     * Override writeValue to allow the date picker
     * element to be updated correctly.
     *
     * @param value - the new value
     */
    writeValue(value: Date | string | number | string[]): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    ngOnDestroy(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    private onListClosed;
    private onListOpened;
    private onBeforeMonthRendered;
    private onMonthRendered;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDatePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoDatePickerComponent, "input[soho-datepicker]", never, { "showTime": { "alias": "showTime"; "required": false; }; "useCurrentTime": { "alias": "useCurrentTime"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; "minuteInterval": { "alias": "minuteInterval"; "required": false; }; "secondInterval": { "alias": "secondInterval"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "autoSize": { "alias": "autoSize"; "required": false; }; "showToday": { "alias": "showToday"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "range": { "alias": "range"; "required": false; }; "roundToInterval": { "alias": "roundToInterval"; "required": false; }; "dateFormat": { "alias": "dateFormat"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "showMonthYearPicker": { "alias": "showMonthYearPicker"; "required": false; }; "showWeekNumber": { "alias": "showWeekNumber"; "required": false; }; "hideDays": { "alias": "hideDays"; "required": false; }; "yearsAhead": { "alias": "yearsAhead"; "required": false; }; "yearsBack": { "alias": "yearsBack"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "calendarName": { "alias": "calendarName"; "required": false; }; "useUTC": { "alias": "useUTC"; "required": false; }; "tabbable": { "alias": "tabbable"; "required": false; }; "incrementWithKeyboard": { "alias": "incrementWithKeyboard"; "required": false; }; "todayWithKeyboard": { "alias": "todayWithKeyboard"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "options": { "alias": "options"; "required": false; }; "validation": { "alias": "validation"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "change": "change"; "listclosed": "listclosed"; "listopened": "listopened"; "beforemonthrendered": "beforemonthrendered"; "monthrendered": "monthrendered"; }, never, ["*"], true, never>;
}

declare class SohoDatePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDatePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoDatePickerModule, never, [typeof SohoDatePickerComponent], [typeof SohoDatePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoDatePickerModule>;
}

declare class SohoDragDirective implements AfterViewInit, OnDestroy {
    private elementRef;
    private ngZone;
    set dragOptions(dragOptions: SohoDragOptions);
    dragStart: EventEmitter<SohoDragEvent>;
    dragEnd: EventEmitter<SohoDragEvent>;
    dragging: EventEmitter<SohoDragEvent>;
    private jQueryElement?;
    private _dragOptions?;
    private drag?;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    getElementsFromPoint(x: number, y: number): Element[];
    ngOnDestroy(): void;
    updated(settings?: SohoDragOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDragDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoDragDirective, "[soho-drag]", never, { "dragOptions": { "alias": "dragOptions"; "required": false; }; }, { "dragStart": "dragStart"; "dragEnd": "dragEnd"; "dragging": "dragging"; }, never, never, true, never>;
}

declare class SohoDragModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDragModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoDragModule, never, [typeof SohoDragDirective], [typeof SohoDragDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoDragModule>;
}

/**
 * Angular wrapper for the `dropdown` widget in the ids-enterprise controls.
 */
declare class SohoDropDownComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    ngControl: NgControl;
    ref: ChangeDetectorRef;
    /**
     * Used to provide unnamed controls with a unique id.
     */
    private static counter;
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    /**
     * Integration with the Angular ControlValueAccessor for form controls.
     */
    private valueAccessor?;
    /**
     * Selector for originating element.
     */
    private jQueryElement?;
    /**
     * Reference to the IDS Enterprise Api.
     */
    private dropdown?;
    /**
     * Default block of options, use the accessors to modify.
     */
    private options;
    private isReadOnly?;
    /**
     * Sets the dropdown to close on selecting a value (helpful for multi-select)
     */
    set closeOnSelect(closeOnSelect: boolean | undefined);
    get closeOnSelect(): boolean | undefined;
    /**
     * Append a css class to the dropdown-list
     */
    set cssClass(cssClass: string | undefined);
    get cssClass(): string | undefined;
    /**
     * Typing debounce for search
     */
    set delay(delay: number | undefined);
    get delay(): number | undefined;
    /**
     * Sets the icon used as the Dropdown Indicator
     */
    set dropdownIcon(icon: string | undefined);
    get dropdownIcon(): string | undefined;
    /**
     * Initialize the empty value
     */
    set empty(empty: boolean | undefined);
    get empty(): boolean | undefined;
    /** Set `no-margin` class to lookup wrapper */
    set noMarginWrapper(noMarginWrapper: boolean | undefined);
    get noMarginWrapper(): boolean | undefined;
    /**
     * Value of the maximum number of selected elements (must have multiple set to true)
     */
    set maxSelected(maxSelected: number | undefined);
    get maxSelected(): number | undefined;
    /**
     * Flag to move the selected values to the top of the dropdown
     *
     * @deprecated use moveSelected
     */
    set moveSelectedToTop(moveSelectedToTop: boolean | undefined);
    get moveSelectedToTop(): boolean | undefined;
    set moveSelected(moveSelected: SohoDropDownMoveSelectedOptions | undefined);
    get moveSelected(): SohoDropDownMoveSelectedOptions | undefined;
    set showEmptyGroupHeaders(showEmptyGroupHeaders: boolean | undefined);
    get showEmptyGroupHeaders(): boolean | undefined;
    set sourceArguments(sourceArguments: any);
    get sourceArguments(): any;
    /**
     * Determines the frequency of reloading data from an external source
     */
    set reload(reload: SohoDropDownReloadStyles);
    get reload(): SohoDropDownReloadStyles;
    /**
     * If set the width of the dropdown is limited to this pixel width.
     * Use 300 for the 300 px size fields. Default is size of the largest data.
     */
    set maxWidth(maxWidth: number | undefined);
    get maxWidth(): number | undefined;
    /**
     * Sets the exact width of the open list, by default its the size of the field
     */
    set width(width: number | undefined);
    get width(): number | undefined;
    set filterMode(filterMode: SohoDropDownFilterModeOptions | undefined);
    get filterMode(): SohoDropDownFilterModeOptions | undefined;
    set virtualScroll(virtualScroll: boolean | undefined);
    get virtualScroll(): boolean | undefined;
    /**
     * Sets the select element as a multi-select
     */
    set multiple(multiple: boolean | undefined);
    get multiple(): boolean | undefined;
    /**
     * Name for the dropdown control. Necessary for ngModel to function.
     */
    name: string;
    /**
     * Flag to add/remove search functionality from the dropdown
     */
    set noSearch(noSearch: boolean | undefined);
    get noSearch(): boolean | undefined;
    /**
     * Existent as a helper... should use framework's API to get data and
     * then create and pass to the control to use
     */
    set source(source: SohoDropDownSourceFunction | Object | string | undefined);
    get source(): SohoDropDownSourceFunction | Object | string | undefined;
    /**
     * Initialize the showSelectAll value for multi-select drop downs
     */
    set showSelectAll(selectAll: boolean | undefined);
    get showSelectAll(): boolean | undefined;
    /**
     * Initialize the showTags value for multi-select drop downs
     */
    set showTags(showTags: boolean | undefined);
    get showTags(): boolean | undefined;
    /**
     * If true, moves the Searchfield in the Dropdown list from directly on top of the pseudo-lement
     * to underneath/above, providing visibility into the currently selected results.
     */
    set showSearchUnderSelected(showSearchUnderSelected: boolean | undefined);
    get showSearchUnderSelected(): boolean | undefined;
    /**
     * If defined, passes along 'clickHandler' and 'dismissHandler' functions to any Tags
     */
    set tagSettings(tagSettings: any);
    get tagSettings(): any;
    /**
     * If defined, passes along 'clickHandler' and 'dismissHandler' functions to any Tags
     */
    set allTextString(allTextString: string | undefined);
    get allTextString(): string | undefined;
    /**
     * @param appendTo additional classes
     */
    set appendTo(appendTo: string);
    /**Custom text string for `Selected` text header use in MultiSelect */
    set selectedTextString(selectedTextString: string);
    get selectedTextString(): string;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /**
     * Called when the dropdown value changes
     *
     * @todo replace override of native attribute
     */
    change$: EventEmitter<JQuery.TriggeredEvent<any, any, any, any>>;
    /**
     * Called when the dropdown updates in some way.
     */
    updated$: EventEmitter<JQuery.TriggeredEvent<any, any, any, any>>;
    /**
     * Fired when the dropdown list is closed.
     */
    listClosed$: EventEmitter<SohoDropDownEvent>;
    /**
     * Fired when the dropdown list is opened.
     */
    listOpened$: EventEmitter<SohoDropDownEvent>;
    /**
     * Fired when the dropdown list is right clicked.
     */
    listContextMenu$: EventEmitter<SohoDropDownEvent>;
    /**
     * This event is fired when a key is pressed
     */
    keydown$: EventEmitter<Event>;
    /**
     * Bind attributes to the host select element
     */
    /**
     * Assign the id for the control
     * (maps to the name to use on a label's 'for' attribute)
     */
    get id(): any;
    get isMultiple(): boolean | undefined;
    get isDropdown(): boolean;
    get isMultiSelect(): any;
    set readonly(readonly: boolean | undefined);
    get readonly(): boolean | undefined;
    /**
     * Creates an instance of SohoDropDownComponent.
     *
     * @param element the element this component encapsulates.
     * @param ngZone the angular zone for this component
     * @param ngControl any associated form control (optional)
     * @param ref the change detector reference, must not be null.
     */
    constructor(element: ElementRef, ngZone: NgZone, ngControl: NgControl, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    /**
     * Event handler for the 'requestend' event on the dropdown 'component'.
     *
     *
     * @param event the standard jQuery event.
     * @param data any data passed by the dropdown (todo the type)
     *
     */
    private onRequestEnd;
    private onUpdated;
    /**
     * Event handler for the 'changed' event on the 'dropdown' component.
     * @param event the standard jQuery event.
     */
    private onChanged;
    /**
     * Event handler for the 'listchanged' event on the 'dropdown' component.
     * @param event the standard jQuery event.
     */
    private onListContextMenu;
    /**
     * Handles the 'listopened' event triggered by the underlying jQuery control.
     *
     * @param event the fired event.
     */
    private onListOpened;
    /**
     * Handles the 'listclosed' event triggered by the underlying jQuery control.
     *
     * @param event the fired event.
     */
    private onListClosed;
    /**
     * In case options are being bound asynchronously, you will need to trigger updated on
     * soho dropdown control so it updates its value labels.
     */
    updated(): SohoDropDownComponent;
    set disabled(value: boolean);
    /**
     * @description
     *
     * Soho-dropdown is not a native element - need this to set focus programmatically.
     */
    setFocus(): void;
    /**
     * @description
     *
     * Sets the value of the dropdown.
     *
     * @todo this may need to involve mapping from actual value
     * if ngModel is used.
     *
     * This is the model value that is to be set.
     * @param value - the internal value to select
     */
    selectValue(value: any): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    /**
     * Adds an inline error message to the dropdown
     *
     * @param message the error message to add.
     */
    addInlineError(message: string): void;
    /**
     * Adds an inline message of the type specified
     *
     * @param message the message to add.
     * @param type optional - 'error' (default)
     * @param isAlert optional - false (default)
     * @param triggerEvents optional - true (default)
     * @param icon optional - icon for the message
     * @param id optional - id for the message
     */
    addInlineMessage(message: string, type?: SohoAlertType, isAlert?: boolean, triggerEvents?: boolean, icon?: string, id?: string): void;
    /**
     * Removes inline message of the specified type
     *
     * @param type the message type to remove ('error', 'alert', etc.)
     * @param triggerEvents optional - true (default)
     */
    removeMessage(type?: SohoAlertType, triggerEvents?: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDropDownComponent, [null, null, { optional: true; self: true; }, null]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoDropDownComponent, "select[soho-dropdown]", never, { "closeOnSelect": { "alias": "closeOnSelect"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "dropdownIcon": { "alias": "dropdownIcon"; "required": false; }; "empty": { "alias": "empty"; "required": false; }; "maxSelected": { "alias": "maxSelected"; "required": false; }; "moveSelectedToTop": { "alias": "moveSelectedToTop"; "required": false; }; "moveSelected": { "alias": "moveSelected"; "required": false; }; "showEmptyGroupHeaders": { "alias": "showEmptyGroupHeaders"; "required": false; }; "sourceArguments": { "alias": "sourceArguments"; "required": false; }; "reload": { "alias": "reload"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "width": { "alias": "width"; "required": false; }; "filterMode": { "alias": "filterMode"; "required": false; }; "virtualScroll": { "alias": "virtualScroll"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "name": { "alias": "name"; "required": false; }; "noSearch": { "alias": "noSearch"; "required": false; }; "source": { "alias": "source"; "required": false; }; "showSelectAll": { "alias": "showSelectAll"; "required": false; }; "showTags": { "alias": "showTags"; "required": false; }; "showSearchUnderSelected": { "alias": "showSearchUnderSelected"; "required": false; }; "tagSettings": { "alias": "tagSettings"; "required": false; }; "allTextString": { "alias": "allTextString"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "selectedTextString": { "alias": "selectedTextString"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "change$": "change"; "updated$": "updated"; "listClosed$": "listclosed"; "listOpened$": "listopened"; "listContextMenu$": "listcontextmenu"; "keydown$": "keydown"; }, never, ["*"], true, never>;
}

declare class SohoDropDownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoDropDownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoDropDownModule, never, [typeof SohoDropDownComponent], [typeof SohoDropDownComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoDropDownModule>;
}

declare class SohoEditorComponent extends BaseControlValueAccessor<any> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    private ref;
    private options;
    /**
     * Local variables
     */
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    private isDisabled?;
    private isReadOnly?;
    get isEditor(): boolean;
    /**
     * Enables or disables the control
     */
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    /**
     * Sets the control to readonly
     */
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    set delay(delay: number);
    set firstHeader(firstHeader: string);
    set secondHeader(secondHeader: string);
    set placeholder(placeholder: string);
    set anchor(anchor: SohoEditorAnchor);
    set image(image: SohoEditorOptionsImage);
    set buttons(buttons: SohoEditorButtons);
    set excludeButtons(buttons: SohoEditorButtons);
    /**
     * onLinkClick Callback for Editor clicks
     */
    set onLinkClick(value: (e: JQuery.TriggeredEvent, elem: any) => void);
    set showHtmlView(showHtmlView: boolean);
    set preview(preview: boolean);
    set rows(rows: SohoEditorRows);
    set attributes(attributes: Array<Object> | Object);
    /**
     * Called when the editor value changes
     *
     * @todo replace override of native attribute
     */
    change: EventEmitter<SohoEditorEvent>;
    /**
     * Called when the editor updates in some way
     */
    updated: EventEmitter<SohoEditorEvent>;
    generateai: EventEmitter<SohoEditorEvent>;
    private jQueryElement?;
    private editor?;
    /**
     * Creates an instance of SohoEditorComponent.
     *
     * @param element the element this component encapsulates.
     * @param ngZone the angualar zone for this component.
     * @param ref reference to the change detector
     */
    constructor(element: ElementRef<HTMLElement>, ngZone: NgZone, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Handle the control being changed.
     */
    onChange(_event: SohoEditorEvent): void;
    /**
     * Handle the generate AI button being clicked
     */
    onGenerateAi(event: SohoEditorEvent): void;
    /**
     * Handle the updated event firing
     */
    onUpdated(event: SohoEditorEvent): void;
    /**
     *
     * @param value Handle model updates.
     */
    writeValue(value: any): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    ngOnDestroy(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoEditorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoEditorComponent, "[soho-editor]", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "firstHeader": { "alias": "firstHeader"; "required": false; }; "secondHeader": { "alias": "secondHeader"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "anchor": { "alias": "anchor"; "required": false; }; "image": { "alias": "image"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "excludeButtons": { "alias": "excludeButtons"; "required": false; }; "onLinkClick": { "alias": "onLinkClick"; "required": false; }; "showHtmlView": { "alias": "showHtmlView"; "required": false; }; "preview": { "alias": "preview"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "change": "change"; "updated": "updated"; "generateai": "generateai"; }, never, ["*"], true, never>;
}

declare class SohoEditorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoEditorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoEditorModule, never, [typeof SohoEditorComponent], [typeof SohoEditorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoEditorModule>;
}

/**
 * Angular Wrapper for the SohoEmptyMessage Control.
 */
declare class SohoEmptyMessageDirective implements AfterViewChecked, AfterViewInit {
    private changeDetector;
    private element;
    /**
     * The `emptyMessage` option.
     */
    set emptyMessageOptions(options: SohoEmptyMessageOptions);
    get emptyMessageOptions(): SohoEmptyMessageOptions;
    set title(title: string | undefined);
    get title(): string | undefined;
    set info(info: string | undefined);
    get info(): string | undefined;
    set icon(icon: string | undefined);
    get icon(): string | undefined;
    set height(height: string | undefined);
    get height(): string | undefined;
    set button(button: SohoEmptyMessageButtonOptions | undefined);
    get button(): SohoEmptyMessageButtonOptions | undefined;
    set color(color: EmptyMessageColor | undefined);
    get color(): EmptyMessageColor | undefined;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    private _emptyMessageOptions;
    private jQueryElement?;
    private emptymessage?;
    private updateComponent;
    constructor(changeDetector: ChangeDetectorRef, element: ElementRef);
    /**
     * After the control has been initialised and the view is ready,
     * construct the empty message sohoxi component.
     */
    ngAfterViewInit(): void;
    /**
     *
     */
    ngAfterViewChecked(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    private markForCheck;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoEmptyMessageDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoEmptyMessageDirective, "[soho-emptymessage]", ["soho-emptymessage"], { "emptyMessageOptions": { "alias": "emptyMessageOptions"; "required": false; }; "title": { "alias": "title"; "required": false; }; "info": { "alias": "info"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "height": { "alias": "height"; "required": false; }; "button": { "alias": "button"; "required": false; }; "color": { "alias": "color"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoEmptyMessageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoEmptyMessageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoEmptyMessageModule, never, [typeof SohoEmptyMessageDirective], [typeof SohoEmptyMessageDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoEmptyMessageModule>;
}

/**
 * Angular Wrapper for the SoHo Error Directive.
 *
 * @deprecated - use SohoAlert instead
 */
declare class SohoErrorDirective implements AfterViewInit {
    private el;
    private _options;
    private jQueryElement?;
    constructor(el: ElementRef);
    /**
     *  message for the error.
     *
     * @deprecated - use SohoAlert instead
     */
    set message(message: string);
    /**
     *  set error in tooltip.
     *
     * @deprecated - use SohoAlert instead
     */
    set showTooltip(showTooltip: boolean);
    /**
     * set error to be inline.
     *
     * @deprecated - use SohoAlert instead
     */
    set inline(inline: boolean);
    /**
     * Returns the data object data-errormessage
     *
     * @deprecated - use SohoAlert instead
     */
    get errorMessage(): JQuery<HTMLElement> | undefined;
    /**
     * add inline error
     *
     * @deprecated - use SohoAlert instead
     */
    addInlineError(message: string): void;
    /**
     * add tooltip error
     *
     * @deprecated - use SohoAlert instead
     */
    addTooltipError(message: string): void;
    /**
     * remove inline/tooltip error
     *
     * @deprecated - use SohoAlert instead
     */
    removeError(): void;
    /**
     * Scrolls the element into the visible area of the browser window
     *
     * @deprecated - use SohoAlert instead
     * @param alignToTop (boolean) optional - true (default) element will be aligned to the top of the visible area of the scrollable ancestor
     */
    scrollIntoView(alignToTop?: boolean): void;
    /**
     * After the control has been initialised and the view is ready,
     * get the SoHoXi controls to activate any validations.
     */
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoErrorDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoErrorDirective, "[soho-error]", ["soho-error"], { "message": { "alias": "message"; "required": false; }; "showTooltip": { "alias": "showTooltip"; "required": false; }; "inline": { "alias": "inline"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoErrorModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoErrorModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoErrorModule, never, [typeof SohoErrorDirective], [typeof SohoErrorDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoErrorModule>;
}

/**
 * Helper Component for the ExpandableAreaComponent
 */
declare class ExpandableHeaderComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableHeaderComponent, "soho-expandable-header", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Helper Component for the ExpandableAreaComponent
 */
declare class ExpandablePaneComponent {
    fixed: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandablePaneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandablePaneComponent, "soho-expandable-pane", never, { "fixed": { "alias": "fixed"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Helper Component for the ExpandableAreaComponent
 */
declare class ExpandableFooterComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableFooterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableFooterComponent, "soho-expandable-footer", never, {}, {}, never, ["*"], true, never>;
}
declare class ExpandableAreaComponent implements AfterViewInit, OnDestroy {
    private element;
    private changeDetectorRef;
    private ngZone;
    id: string | undefined;
    trigger?: string;
    set disabled(value: boolean | undefined);
    /**
     * Boolean value of the disabled state of the component
     */
    get disabled(): boolean | undefined;
    set closed(value: boolean | undefined);
    /**
     * Boolean value of the closed state of the component
     */
    get closed(): boolean | undefined;
    toggle?: Observable<boolean>;
    header: ExpandableHeaderComponent | undefined;
    panes: QueryList<ExpandablePaneComponent> | undefined;
    footer?: ExpandablePaneComponent;
    beforeexpand: EventEmitter<Object>;
    beforecollapse: EventEmitter<Object>;
    expand: EventEmitter<Object>;
    collapse: EventEmitter<Object>;
    afterexpand: EventEmitter<Object>;
    aftercollapse: EventEmitter<Object>;
    private jQueryElement?;
    private expandablearea?;
    private _disabled?;
    private _closed?;
    hasFixedPane: boolean;
    constructor(element: ElementRef, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Calls the expandablearea disable function
     */
    disable(): void;
    /**
     * Calls the expandablearea enable function
     */
    enable(): void;
    /**
     * Toggles the state of the expandablearea (open or closed) based on the passed
     * parameter.
     */
    toggleOpen(open: boolean): void;
    close(): void;
    open(): void;
    /**
     * The class setter for the expandable area div element
     */
    get expandableAreaClasses(): string;
    /**
     * The class setter for the header element
     */
    get headerClasses(): string;
    /**
     * The class setter for the pane element
     */
    get paneClasses(): string;
    /**
     * The class setter for the pane element
     */
    get footerClasses(): string;
    /**
     * The class setter for the visible pane element
     */
    get visiblePaneClasses(): string;
    private onBeforeExpand;
    private onBeforeCollapse;
    private onExpand;
    private onCollapse;
    private onAfterExpand;
    private onAfterCollapse;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<ExpandableAreaComponent, "soho-expandable-area", never, { "id": { "alias": "soho-expandable-area"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "closed": { "alias": "closed"; "required": false; }; "toggle": { "alias": "toggle"; "required": false; }; }, { "beforeexpand": "beforeexpand"; "beforecollapse": "beforecollapse"; "expand": "expand"; "collapse": "collapse"; "afterexpand": "afterexpand"; "aftercollapse": "aftercollapse"; }, ["header", "footer", "panes"], ["soho-expandable-header", "soho-expandable-pane[fixed=true]", "soho-expandable-pane", "soho-expandable-footer"], true, never>;
}

declare class SohoExpandableAreaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoExpandableAreaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoExpandableAreaModule, never, [typeof ExpandableAreaComponent, typeof ExpandableFooterComponent, typeof ExpandableHeaderComponent, typeof ExpandablePaneComponent], [typeof ExpandableAreaComponent, typeof ExpandableFooterComponent, typeof ExpandableHeaderComponent, typeof ExpandablePaneComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoExpandableAreaModule>;
}

declare class SohoFieldFilterDirective implements AfterViewChecked, AfterViewInit, OnDestroy {
    private ref;
    private element;
    private ngZone;
    set fieldSettings(settings: SohoFieldFilterSettings);
    set fieldDropdownDataSet(dataset: Array<SohoFieldFilterOption>);
    set dropdownOpts(options: SohoDropDownOptions);
    set template(template: string);
    set selectedFilterType(type: SohoFieldFilterOperator);
    filtered: EventEmitter<SohoFieldFilteredEvent>;
    private _settings;
    /**
     * Local variables
     */
    private jQueryElement?;
    private fieldFilter?;
    private runUpdatedOnCheck?;
    constructor(ref: ChangeDetectorRef, element: ElementRef, ngZone: NgZone);
    ngAfterViewChecked(): void;
    ngAfterViewInit(): void;
    /**
     * Get current filter type
     * returns {object} The current filter type
     */
    getFilterType(): any;
    /**
     * Set filter type to given value
     * param {number|string} value to be set, index or value.
     * returns {void}
     */
    setFilterType(value: SohoFieldFilterOperator | number | string): void;
    /** Destructor. */
    ngOnDestroy(): void;
    markForRefresh(): void;
    private onFiltered;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFieldFilterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoFieldFilterDirective, "[soho-field-filter]", never, { "fieldSettings": { "alias": "fieldSettings"; "required": false; }; "fieldDropdownDataSet": { "alias": "fieldDropdownDataSet"; "required": false; }; "dropdownOpts": { "alias": "dropdownOpts"; "required": false; }; "template": { "alias": "template"; "required": false; }; "selectedFilterType": { "alias": "selectedFilterType"; "required": false; }; }, { "filtered": "filtered"; }, never, never, true, never>;
}

declare class SohoFieldFilterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFieldFilterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoFieldFilterModule, never, [typeof SohoFieldFilterDirective], [typeof SohoFieldFilterDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoFieldFilterModule>;
}

declare class SohoFieldOptionsDirective implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    private _options;
    allFieldOptions: boolean;
    /**
     * Local variables
     */
    private jQueryElement?;
    private fieldOptions?;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    /** Destructor. */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFieldOptionsDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoFieldOptionsDirective, "[soho-field-options]", never, {}, {}, never, never, true, never>;
}

declare class SohoFieldOptionsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFieldOptionsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoFieldOptionsModule, never, [typeof SohoFieldOptionsDirective], [typeof SohoFieldOptionsDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoFieldOptionsModule>;
}

interface SohoRevealTextSettings {
    initialState?: 'show' | 'hide';
    revealCharacters?: number;
    maskingType?: 'digit' | 'email' | 'phone' | 'address' | 'birthday' | string;
    revealBtn?: 'icon' | 'text' | string;
    revealPosition?: 'start' | 'end' | string;
}
declare class SohoRevealableTextMaskDirective implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    set revealTextSettings(settings: SohoRevealTextSettings);
    private _settings;
    private jQueryElement?;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    private initRevealText;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRevealableTextMaskDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoRevealableTextMaskDirective, "[soho-revealable-text-mask]", never, { "revealTextSettings": { "alias": "revealTextSettings"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoFieldSetModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFieldSetModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoFieldSetModule, never, [typeof SohoRevealableTextMaskDirective], [typeof SohoRevealableTextMaskDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoFieldSetModule>;
}

declare class SohoFileUploadComponent implements AfterViewInit, OnDestroy {
    private element;
    private changeDetectorRef;
    private ngZone;
    get isFileUpload(): boolean;
    get isFileUploadType(): string;
    /**
     * Local variables
     */
    isDisabled?: boolean;
    isReadOnly?: boolean;
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    /**
     * Called when the fileupload value changes
     *
     * @todo replace override of native attribute
     */
    change: EventEmitter<SohoFileUploadEvent>;
    private jQueryElement?;
    private fileUpload?;
    private options;
    constructor(element: ElementRef, changeDetectorRef: ChangeDetectorRef, ngZone: NgZone);
    /** Called when the value changes. */
    changeEvent: EventEmitter<SohoFileUploadEvent>;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    set tabbable(value: boolean | undefined);
    get tabbable(): boolean | undefined;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clearUploadFile(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFileUploadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoFileUploadComponent, "input[soho-fileupload]", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "tabbable": { "alias": "tabbable"; "required": false; }; }, { "change": "change"; "changeEvent": "changeEvent"; }, never, ["*"], true, never>;
}

declare class SohoFileUploadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFileUploadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoFileUploadModule, never, [typeof SohoFileUploadComponent], [typeof SohoFileUploadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoFileUploadModule>;
}

declare class SohoFileUploadAdvancedComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ref;
    private ngZone;
    /**
     * Add class to host element to ensure correct styling and detection by EP controls.
     */
    isFileUploadAdvanced: boolean;
    /**
     * Local variables
     */
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    /** Keeps track of the enabled / disabled state. */
    isDisabled?: boolean;
    /**
     * Set the disabled state of the control.
     */
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    /**
     * Show or hide the progress bar.
     *
     * @param progressBar - If true, shows the progress bar; otherwise hides it.
     */
    set progressBar(value: boolean | undefined);
    get progressBar(): boolean | undefined;
    /**
     * On page(true) -or- on modal (false) , this is used for some visual style only.
     *
     * @param isStandalone true for onPage otherwise false.
     */
    set isStandalone(isStandaline: boolean | undefined);
    get isStandalone(): boolean | undefined;
    /**
     * Restrict file types(ie. 'jpg|png|gif') ['*' all types]
     *
     * @param allowedTypes - the allowed types.
     */
    set allowedTypes(allowedTypes: string | undefined);
    get allowedTypes(): string | undefined;
    /**
     * Defines the send method used to upload the files.
     *
     * The send function takes the FormData containing the file, and a
     * status interface to provide fedback to the control whilst uploading.
     *
     * @param sendFn - the callback function responsible to uploading the file.
     */
    set send(sendFn: SohoFileUploadAdvancedSendFunction | any);
    get send(): any;
    /**
     * Restricts the number of files that can be retrieved in total.
     *
     * @param maxFiles - max files cab be upload.
     */
    set maxFiles(maxFiles: number | undefined);
    get maxFiles(): number | undefined;
    /**
     * Restricts the number of files that can be retrieved while in process.
     *
     * @param maxFilesInProcess - the callback function responsible to uploading the file.
     */
    set maxFilesInProcess(maxFilesInProcess: number | undefined);
    get maxFilesInProcess(): number | undefined;
    /**
     * Max file size in bytes, -1 for unlimited.
     *
     * @param maxFileSize - Max file size in bytes, -1 for unlimited.
     */
    set maxFileSize(maxFileSize: number | undefined);
    get maxFileSize(): number | undefined;
    /**
     * Variable name to read from server.
     *
     * @param fileName - Variable name to read from server..
     */
    set fileName(fileName: string | undefined);
    get fileName(): string | undefined;
    /**
     * Add way to browse files to upload
     *
     * @param showBrowseButton - if true, displays the browse button; otherwise do not.
     */
    set showBrowseButton(showBrowseButton: boolean | undefined);
    get showBrowseButton(): boolean | undefined;
    /**
     * Text to show in drop area.
     *
     * @param textDropArea - Text to show in drop area.
     */
    set textDropArea(textDropArea: string | undefined);
    get textDropArea(): string | undefined;
    /**
     * Text to show in drop area when browse option true.
     *
     * @param textDropAreaWithBrowse - Text to show in drop area when browse option true.
     */
    set textDropAreaWithBrowse(textDropAreaWithBrowse: string | undefined);
    get textDropAreaWithBrowse(): string | undefined;
    /**
     * Hidden text for cancel button.
     *
     * @param textBtnCancel - Hidden text for cancel button.
     */
    set textBtnCancel(textBtnCancel: string | undefined);
    get textBtnCancel(): string | undefined;
    /**
     * Hidden text for error close button
     *
     * @param textBtnCloseError - Hidden text for error close button.
     */
    set textBtnCloseError(textBtnCloseError: string | undefined);
    get textBtnCloseError(): string | undefined;
    /**
     * Hidden text for remove button.
     *
     * @param textBtnRemove - Hidden text for remove button.
     */
    set textBtnRemove(textBtnRemove: string | undefined);
    get textBtnRemove(): string | undefined;
    /**
     *
     */
    set errorMaxFiles(errorMaxFiles: string | undefined);
    get errorMaxFiles(): string | undefined;
    /**
     *
     */
    set errorMaxFilesInProcess(errorMaxFilesInProcess: string | undefined);
    get errorMaxFilesInProcess(): string | undefined;
    /**
     *
     */
    set errorMaxFileSize(errorMaxFilesSize: string | undefined);
    get errorMaxFileSize(): string | undefined;
    /**
     * Called when the fileupload value changes
     */
    filesdragenter: EventEmitter<JQuery.TriggeredEvent<any, any, any, any>>;
    filesdropped: EventEmitter<File[]>;
    beforecreatestatus: EventEmitter<File[]>;
    aftercreatestatus: EventEmitter<File[]>;
    fileprogress: EventEmitter<File[]>;
    fileaborted: EventEmitter<File[]>;
    filecompleteduploading: EventEmitter<File[]>;
    fileremoved: EventEmitter<File[]>;
    filefailed: EventEmitter<File[]>;
    /** Set of options for this control. */
    private options;
    private jQueryElement?;
    private fileuploadadvanced?;
    /**
     * Updates the control by merging the given settings into
     * the EP widget.
     *
     * @param settings the settings to merge.
     */
    updated(settings: SohoFileUploadAdvancedOptions): void;
    /**
     * Destroys the control.
     */
    destroy(): void;
    /**
     * Set status of a file in progress to failed
     */
    setFailed(error: string, fileIndex?: number): void;
    /**
     * Constructor.
     */
    constructor(element: ElementRef, ref: ChangeDetectorRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFileUploadAdvancedComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoFileUploadAdvancedComponent, "soho-fileupload-advanced,div[soho-fileupload-advanced]", never, { "disabled": { "alias": "disabled"; "required": false; }; "progressBar": { "alias": "progressBar"; "required": false; }; "isStandalone": { "alias": "isStandalone"; "required": false; }; "allowedTypes": { "alias": "allowedTypes"; "required": false; }; "send": { "alias": "send"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; "maxFilesInProcess": { "alias": "maxFilesInProcess"; "required": false; }; "maxFileSize": { "alias": "maxFileSize"; "required": false; }; "fileName": { "alias": "fileName"; "required": false; }; "showBrowseButton": { "alias": "showBrowseButton"; "required": false; }; "textDropArea": { "alias": "textDropArea"; "required": false; }; "textDropAreaWithBrowse": { "alias": "textDropAreaWithBrowse"; "required": false; }; "textBtnCancel": { "alias": "textBtnCancel"; "required": false; }; "textBtnCloseError": { "alias": "textBtnCloseError"; "required": false; }; "textBtnRemove": { "alias": "textBtnRemove"; "required": false; }; "errorMaxFiles": { "alias": "errorMaxFiles"; "required": false; }; "errorMaxFilesInProcess": { "alias": "errorMaxFilesInProcess"; "required": false; }; "errorMaxFileSize": { "alias": "errorMaxFileSize"; "required": false; }; }, { "filesdragenter": "filesdragenter"; "filesdropped": "filesdropped"; "beforecreatestatus": "beforecreatestatus"; "aftercreatestatus": "aftercreatestatus"; "fileprogress": "fileprogress"; "fileaborted": "fileaborted"; "filecompleteduploading": "filecompleteduploading"; "fileremoved": "fileremoved"; "filefailed": "filefailed"; }, never, ["*"], true, never>;
}

declare class SohoFileUploadAdvancedModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFileUploadAdvancedModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoFileUploadAdvancedModule, never, [typeof SohoFileUploadAdvancedComponent], [typeof SohoFileUploadAdvancedComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoFileUploadAdvancedModule>;
}

declare class SohoFormCompactComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isFormCompact(): boolean;
    private jQueryElement?;
    private formcompact?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFormCompactComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoFormCompactComponent, "[soho-form-compact]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoFormCompactModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFormCompactModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoFormCompactModule, never, [typeof SohoFormCompactComponent], [typeof SohoFormCompactComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoFormCompactModule>;
}

declare class SohoHierarchyLeafTemplateComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHierarchyLeafTemplateComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoHierarchyLeafTemplateComponent, "soho-hierarchy-leaf-template", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoHierarchyComponent implements OnDestroy, AfterViewInit {
    private elementRef;
    private ngZone;
    private hierarchy?;
    private jQueryElement?;
    /** An internal options object that gets updated by using the component's Inputs(). */
    private options;
    hostClass: string;
    set dataset(dataset: Array<any> | undefined);
    get dataset(): Array<any> | undefined;
    set legend(legend: Array<SohoHierarchyLegend> | undefined);
    get legend(): Array<SohoHierarchyLegend> | undefined;
    set legendKey(key: string | undefined);
    get legendKey(): string | undefined;
    set templateId(id: string | undefined);
    get leafTemplateId(): string | undefined;
    set layout(layout: SohoHierarchyLayoutType | undefined);
    get layout(): SohoHierarchyLayoutType | undefined;
    /**
     * Leaf is selected
     *
     */
    selected: EventEmitter<SohoHierarchyEvent>;
    /**
     * Leaf is double clicked.
     */
    doubleClick: EventEmitter<SohoHierarchyDoubleClickEvent>;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    /**
     * Used to add new data lazily when a leaf is expanded
     *
     * @param id should match the leaf id in the DOM
     */
    add(id: string, dataset: Array<any>, newData: Array<any>): void;
    /**
     *  Reload hierarchy with a new dataset
     */
    reloadDataSet(dataSet: Array<any>): void;
    /**
     * Update actions for action menu on a leaf
     */
    updateActions(eventInfo: SohoHierarchyEvent, updatedActions: Array<SohoHierarchyAction>): void;
    /**
     * Manually select leaf by id
     */
    selectLeaf(leafId: string): void;
    ngOnDestroy(): void;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHierarchyComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoHierarchyComponent, "figure[soho-hierarchy]", never, { "dataset": { "alias": "dataset"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "legendKey": { "alias": "legendKey"; "required": false; }; "templateId": { "alias": "templateId"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; }, { "selected": "selected"; "doubleClick": "doubleClick"; }, never, ["*"], true, never>;
}

declare class SohoHierarchyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHierarchyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoHierarchyModule, never, [typeof SohoHierarchyComponent, typeof SohoHierarchyLeafTemplateComponent], [typeof SohoHierarchyComponent, typeof SohoHierarchyLeafTemplateComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoHierarchyModule>;
}

declare class SohoHeaderComponent implements AfterViewInit, OnDestroy {
    private elementRef;
    isHeader: boolean;
    isPersonalizable: boolean;
    hasToolbar: any;
    hasTabs: any;
    /**
     * This event is fired when the status of the header is changed.
     *
     */
    updated: EventEmitter<any>;
    private jQueryElement?;
    private header?;
    constructor(elementRef: ElementRef);
    /**
     * Used to manually remove the back button when
     * Which is used in the header via the list/detail pattern
     */
    removeBackButton(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoHeaderComponent, "soho-header", never, { "hasToolbar": { "alias": "hasToolbar"; "required": false; }; "hasTabs": { "alias": "hasTabs"; "required": false; }; }, { "updated": "updated"; }, never, ["*"], true, never>;
}

declare class SohoHeaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHeaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoHeaderModule, never, [typeof SohoHeaderComponent], [typeof SohoHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoHeaderModule>;
}

declare class SohoHomePageComponent implements AfterViewInit, OnDestroy {
    private elementRef;
    private ngZone;
    /**
     * @todo replace override of native attribute
     */
    resize: EventEmitter<SohoHomePageEvent>;
    resizecard: EventEmitter<SohoHomePageEditEvent>;
    reordercard: EventEmitter<SohoHomePageEditEvent>;
    removecard: EventEmitter<SohoHomePageEditEvent>;
    set homePageOptions(homePageOptions: SohoHomePageOptions);
    get homePageOptions(): SohoHomePageOptions;
    /**
     * Whether to animate widget placement
     */
    set animate(animate: boolean | undefined);
    get animate(): boolean | undefined;
    /**
     * Sets the maximum number of widget columns
     */
    set columns(columns: number | undefined);
    get columns(): number | undefined;
    /**
     * Set edit for rearranging/reordering cards.
     */
    set editing(editing: boolean | undefined);
    get editing(): boolean | undefined;
    /**
     * Specify the speed at which an animation progresses at different points within the animation.
     */
    set easing(easing: EasingType | undefined);
    get easing(): EasingType | undefined;
    /**
     * Sets gutter size in between widgets
     */
    set gutterSize(gutterSize: number | undefined);
    get gutterSize(): number | undefined;
    /**
     * Sets the default widget width in pixels
     */
    set widgetWidth(widgetWidth: number | undefined);
    get widgetWidth(): number | undefined;
    /**
     * Sets the default widget height in pixels
     */
    set widgetHeight(widgetHeight: number | undefined);
    get widgetHeight(): number | undefined;
    /**
     * Sets the widgets to smaller size
     */
    set useSmall(useSmall: boolean | undefined);
    get useSmall(): boolean | undefined;
    /**
     * this ...
     */
    set timeout(timeout: number | undefined);
    get timeout(): number | undefined;
    /**
     * Event fired before a card is removed
     *
     * @param beforeSelectFunction Function callback
     */
    set onBeforeRemoveCard(beforeSelectFunction: SohoHomePageBeforeRemoveCardFunction | undefined);
    get onBeforeRemoveCard(): SohoHomePageBeforeRemoveCardFunction | undefined;
    set banner(banner: SohoHomePageBannerOptions | undefined);
    get banner(): SohoHomePageBannerOptions | undefined;
    isHomepage: boolean;
    private jQueryElement?;
    private homepage?;
    private _homePageOptions;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    /**
     * Reset columns to their defaults (used on restore menu item).
     */
    refresh(animate?: boolean): void;
    ngAfterViewInit(): void;
    onResize(columns: number, metadata: object): void;
    onResizeCard(card: JQuery, metadata: object): void;
    onReorderCard(card: JQuery, metadata: object): void;
    onRemoveCard(card: JQuery, metadata: object): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHomePageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoHomePageComponent, "div[soho-homepage]", never, { "homePageOptions": { "alias": "homePageOptions"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "editing": { "alias": "editing"; "required": false; }; "easing": { "alias": "easing"; "required": false; }; "gutterSize": { "alias": "gutterSize"; "required": false; }; "widgetWidth": { "alias": "widgetWidth"; "required": false; }; "widgetHeight": { "alias": "widgetHeight"; "required": false; }; "useSmall": { "alias": "useSmall"; "required": false; }; "timeout": { "alias": "timeout"; "required": false; }; "onBeforeRemoveCard": { "alias": "onBeforeRemoveCard"; "required": false; }; "banner": { "alias": "banner"; "required": false; }; }, { "resize": "resize"; "resizecard": "resizecard"; "reordercard": "reordercard"; "removecard": "removecard"; }, never, ["*"], true, never>;
}

type WidgetSize = 'single' | 'double' | 'triple' | 'quad';
declare class SohoWidgetComponent implements AfterViewInit, OnInit {
    private elementRef;
    private ngZone;
    get classList(): string;
    isWidget: boolean;
    get isNoHeader(): boolean | undefined;
    get isNoShadow(): boolean | undefined;
    widgetWidth?: WidgetSize;
    widgetHeight?: WidgetSize | 'auto';
    removable?: boolean;
    noHeader: boolean | undefined;
    noShadow: boolean | undefined;
    set contentPaddingX(value: number | undefined);
    set bordered(value: boolean | string | undefined);
    set contentPaddingY(value: number | undefined);
    set detailRefId(value: string | undefined);
    resizecard: EventEmitter<any>;
    reordercard: EventEmitter<any>;
    removecard: EventEmitter<any>;
    private options;
    private cards?;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    private jQueryElement?;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    onResizeCard(card: JQuery<HTMLElement>, metadata: object): void;
    onReorderCard(card: JQuery<HTMLElement>, metadata: object): void;
    onRemoveCard(card: JQuery<HTMLElement>, metadata: object): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWidgetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWidgetComponent, "div[soho-widget]", never, { "widgetWidth": { "alias": "widgetWidth"; "required": false; }; "widgetHeight": { "alias": "widgetHeight"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "noHeader": { "alias": "noHeader"; "required": false; }; "noShadow": { "alias": "noShadow"; "required": false; }; "contentPaddingX": { "alias": "contentPaddingX"; "required": false; }; "bordered": { "alias": "bordered"; "required": false; }; "contentPaddingY": { "alias": "contentPaddingY"; "required": false; }; "detailRefId": { "alias": "detailRefId"; "required": false; }; }, { "resizecard": "resizecard"; "reordercard": "reordercard"; "removecard": "removecard"; }, never, ["*"], true, never>;
}

declare class SohoWidgetContentComponent {
    isWidgetContent: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWidgetContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWidgetContentComponent, "div[soho-widget-content]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoWidgetHeaderComponent {
    isWidgetHeader: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWidgetHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWidgetHeaderComponent, "div[soho-widget-header]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoWidgetTitleComponent {
    tabIndex?: number;
    isWidgetTitle: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWidgetTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWidgetTitleComponent, "[soho-widget-title]", never, { "tabIndex": { "alias": "tabIndex"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Angular Directive for keeping a homepage elements height correctly up to date.
 */
declare class SohoHomepageSizerDirective implements AfterViewInit, OnDestroy {
    elementRef: ElementRef;
    private ngZone;
    get heightStyle(): number | undefined;
    private jQueryElement?;
    private containerHeight?;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHomepageSizerDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoHomepageSizerDirective, "[soho-homepage-sizer]", never, {}, {}, never, never, true, never>;
}

declare class SohoHomePageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHomePageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoHomePageModule, never, [typeof SohoHomePageComponent, typeof SohoHomepageSizerDirective, typeof SohoWidgetComponent, typeof SohoWidgetContentComponent, typeof SohoWidgetHeaderComponent, typeof SohoWidgetTitleComponent], [typeof SohoHomePageComponent, typeof SohoHomepageSizerDirective, typeof SohoWidgetComponent, typeof SohoWidgetContentComponent, typeof SohoWidgetHeaderComponent, typeof SohoWidgetTitleComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoHomePageModule>;
}

type SohoHyperlinkType = 'show-visited' | 'forward-caret' | 'back-caret';
declare class SohoHyperlinkComponent implements AfterViewInit {
    private element;
    static SHOWVISITED: SohoHyperlinkType;
    static DIRECTIONAL: SohoHyperlinkType;
    static BACK: SohoHyperlinkType;
    /**
     * The type of the hyperlink, defaulting to 'hide-focus'.
     *
     * @todo replace override of native attribute
     */
    set sohoHyperlink(type: SohoHyperlinkType | "" | undefined);
    icon?: string;
    /**
     * Sets the expandable-expander class to be placed on the button for the
     * soho-expandablearea to use as it's expand/collapse trigger
     *
     */
    expandableExpander: boolean;
    /**
     * @todo replace override of native attribute
     */
    change?: EventEmitter<SohoHyperlinkEvent>;
    hyperLinkClass: boolean;
    get showVisitedClass(): true | undefined;
    get directionalClass(): true | undefined;
    get backClass(): true | undefined;
    href?: string;
    disabled?: boolean;
    isCaretRight?: boolean;
    isCaretLeft?: boolean;
    get isExpandableExpander(): boolean;
    private hyperlinkType?;
    private jQueryElement?;
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHyperlinkComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoHyperlinkComponent, "a[soho-hyperlink]", never, { "sohoHyperlink": { "alias": "soho-hyperlink"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "expandableExpander": { "alias": "expandableExpander"; "required": false; }; "href": { "alias": "href"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "isCaretRight": { "alias": "isCaretRight"; "required": false; }; "isCaretLeft": { "alias": "isCaretLeft"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class SohoHyperlinkModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoHyperlinkModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoHyperlinkModule, never, [typeof SohoIconModule, typeof SohoHyperlinkComponent], [typeof SohoHyperlinkComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoHyperlinkModule>;
}

declare class SohoInputComponent extends BaseControlValueAccessor<string> implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    /**
     * todo: work around until landmark can change code to allow the initial format.
     * Right now landmark initially formats the value to current locale.
     */
    fireInputEventKludge: boolean;
    /**
     * Available Soho Template events as Output (EventEmitters passing the event)
     * Should match the Soho event names for the component
     *
     * @todo replace override of native attribute
     */
    change: EventEmitter<SohoInputEvent[]>;
    /**
     * Input controls managed their disabled state via the 'disabled' attribute.
     * We use null as the default, rather than false, to ensure the attribute is
     * not displayed.
     *
     *
     */
    isDisabled: boolean | undefined;
    /**
     * Clearable attribute. Adds a clear icon in input if true.
     */
    clearable: boolean | undefined;
    /**
     * Local variables
     */
    private jQueryElement?;
    /**
     * Constructor.
     *
     * @param element the owning element.
     * @param changeDetectionRef change detection.
     */
    constructor(element: ElementRef, ngZone: NgZone);
    onKeyUp(_event: KeyboardEvent): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Handle the control being changed.
     */
    onChange(event: any[]): void;
    /**
     * Override writeValue to allow the mask input
     * element to be updated correctly.
     *
     * @param value - the new value
     */
    writeValue(value: any): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean | undefined): void;
    getValue(): string | undefined;
    setValue(value: string): void;
    focus(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoInputComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoInputComponent, "input[soho-input]", never, { "fireInputEventKludge": { "alias": "fireInputEventKludge"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class SohoInputModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoInputModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoInputModule, never, [typeof SohoInputComponent], [typeof SohoInputComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoInputModule>;
}

/**
 * Angular Wrapper for the SoHo Input Validate Directive.
 *
 * This component searches for an element with the attribute
 * 'data-validate' or 'data-validate-on="submit"'.
 */
declare class SohoInputValidateDirective implements AfterViewInit, OnDestroy {
    private el;
    private ngZone;
    /**
     * Local variables
     */
    private jQueryElement?;
    private validator?;
    dataValidate: string;
    /**
     * @todo replace override of native attribute
     */
    error: EventEmitter<SohoInputValidateEvent>;
    alert: EventEmitter<SohoInputValidateEvent>;
    /**
     * @todo replace override of native attribute
     */
    success: EventEmitter<SohoInputValidateEvent>;
    icon: EventEmitter<SohoInputValidateEvent>;
    info: EventEmitter<SohoInputValidateEvent>;
    valid: EventEmitter<SohoInputValidateEvent>;
    constructor(el: ElementRef, dataValidateAttr: any, // eslint-disable-line
    ngZone: NgZone);
    /**
     * After the control has been initialised and the view is ready,
     * get the SoHoXi controls to activate any validations.
     */
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    /**
     * Remove the message from the field if there is one and mark the field valid
     */
    removeMessage(type: any): void;
    /**
     * Trigger validation of the field
     */
    validate(event: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoInputValidateDirective, [null, { attribute: "data-validate"; }, null]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoInputValidateDirective, "form[soho-input-validate], input[soho-input-validate], input[data-validate], input[data-validate-on=\"submit\"], textarea[data-validate], select[data-validate]", never, { "dataValidate": { "alias": "data-validate"; "required": false; }; }, { "error": "error"; "alert": "alert"; "success": "success"; "icon": "icon"; "info": "info"; "valid": "valid"; }, never, never, true, never>;
}

declare class SohoInputValidateModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoInputValidateModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoInputValidateModule, never, [typeof SohoInputValidateDirective], [typeof SohoInputValidateDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoInputValidateModule>;
}

declare class SohoLabelDirective implements AfterViewInit {
    private element;
    /**
     * Indicate that the label is audible
     */
    audible?: boolean;
    /**
     * Indicate that the label is required
     */
    required?: boolean;
    /**
     * Indicate that the label is for checkbox or non-checkbox
     */
    forCheckBox?: boolean;
    /**
     * Indicate that the label is for radiobutton or non-radiobutton
     */
    forRadioButton?: boolean;
    /**
     * Bind attributes to the host label element
     */
    get isLabel(): boolean;
    get isCheckBoxLabel(): boolean | undefined;
    get isRadioButtonLabel(): boolean | undefined;
    get isAudible(): boolean;
    get isRequired(): boolean;
    /**
     * Local variables
     */
    jQueryElement?: JQuery;
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoLabelDirective, "label[soho-label]", never, { "audible": { "alias": "audible"; "required": false; }; "required": { "alias": "required"; "required": false; }; "forCheckBox": { "alias": "forCheckBox"; "required": false; }; "forRadioButton": { "alias": "forRadioButton"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoLabelModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLabelModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoLabelModule, never, [typeof SohoLabelDirective], [typeof SohoLabelDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoLabelModule>;
}

declare class SohoLineComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isLine(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any>);
    set tooltip(value: string);
    set isArea(value: boolean);
    set isBubble(value: boolean);
    set showLegend(value: boolean);
    set xAxis(value: object);
    set yAxis(value: object);
    set hideDots(value: boolean);
    set axisLabels(value: any);
    set animate(value: boolean);
    set redrawOnResize(value: boolean);
    set dots(value: object);
    set formatterString(value: string);
    set emptyMessage(value: SohoEmptyMessageOptions);
    selected: EventEmitter<SohoLineSelectEvent>;
    unselected: EventEmitter<SohoLineSelectEvent>;
    rendered: EventEmitter<Object>;
    dblclick: EventEmitter<Object>;
    /**
     * @todo replace override of native attribute
     */
    contextmenu: EventEmitter<Object>;
    private jQueryElement?;
    private line?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    updated(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    setSelected(selected: SohoLineSelected): void;
    toggleSelected(selected: SohoLineSelected): void;
    getSelected(): Object | Object[] | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoLineComponent, "[soho-line]", never, { "dataset": { "alias": "dataset"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "isArea": { "alias": "isArea"; "required": false; }; "isBubble": { "alias": "isBubble"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "xAxis": { "alias": "xAxis"; "required": false; }; "yAxis": { "alias": "yAxis"; "required": false; }; "hideDots": { "alias": "hideDots"; "required": false; }; "axisLabels": { "alias": "axisLabels"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "dots": { "alias": "dots"; "required": false; }; "formatterString": { "alias": "formatterString"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; }, { "selected": "selected"; "unselected": "unselected"; "rendered": "rendered"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoLineModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLineModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoLineModule, never, [typeof SohoLineComponent], [typeof SohoLineComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoLineModule>;
}

declare class SohoSearchFieldWrapperComponent {
    get isSearchfieldWrapper(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSearchFieldWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSearchFieldWrapperComponent, "[soho-searchfield-wrapper]", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoSearchFieldComponent implements AfterViewInit, OnDestroy, AfterViewChecked {
    private element;
    private ngZone;
    ref: ChangeDetectorRef;
    ngControl: NgControl;
    /** Options. */
    options: SohoSearchFieldOptions;
    set allResultsCallback(value: (searchTerm: string) => void);
    /** Displays a dropdown containing categories that can be used to filter results. */
    set categories(value: SohoSearchFieldCategoryType[]);
    /** If true, creates a multiselectable Categories list. */
    set categoryMultiselect(value: boolean);
    /** Has an X to clear. */
    set clearable(value: boolean);
    set showAllResults(value: boolean);
    /** Show any available categories that are selected to teh left of the Dropdown field. */
    set showCategoryText(value: boolean);
    /** Extra button available to show. */
    set button(value: SohoSearchFieldExtraButton);
    /** AutoComplete : Source Function/Data/Url/Array */
    set source(value: SohoAutoCompleteSource);
    /** Template that can be passed */
    set template(value: string);
    /** Number representing a size that will be used when a collapsible Searchfield becomes collapsed. */
    set collapseSize(value: ((api: SohoSearchFieldStatic) => number) | number);
    /** Set the input to tabbable */
    set tabbable(value: boolean);
    selected: EventEmitter<Object[]>;
    cleared: EventEmitter<Object[]>;
    get isSearchField(): boolean;
    /**
     * Local variables
     */
    private jQueryElement?;
    private searchfield?;
    /**
     * Integration with the Angular ControlValueAccessor for form controls.
     */
    private valueAccessor?;
    runUpdatedOnCheck: boolean;
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef, ngControl: NgControl);
    ngAfterViewChecked(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    clear(): void;
    /**  Gets a complete list of categories in jQuery-collection form. */
    getCategories(): any;
    /** Gets the categories as data. Passing true will return only the selected category data.*/
    getCategoryData(onlySelected: boolean): SohoSearchFieldCategory[] | undefined;
    /**  Gets a complete list of categories in jQuery-collection form. */
    getSelectedCategories(): any;
    /** Gets the currently selected list of categories in jQuery-collection form. */
    setCategoryButtonText(textContent?: string): void;
    updated(settings?: SohoSearchFieldOptions): void;
    checkContents(): void;
    /** Expand the searchfield (for collapsible searchfields) */
    expand(): void;
    /** Collapse the searchfield (for collapsible searchfields) */
    collapse(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSearchFieldComponent, [null, null, null, { optional: true; self: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSearchFieldComponent, "input[soho-searchfield]", never, { "options": { "alias": "options"; "required": false; }; "allResultsCallback": { "alias": "allResultsCallback"; "required": false; }; "categories": { "alias": "categories"; "required": false; }; "categoryMultiselect": { "alias": "categoryMultiselect"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "showAllResults": { "alias": "showAllResults"; "required": false; }; "showCategoryText": { "alias": "showCategoryText"; "required": false; }; "button": { "alias": "button"; "required": false; }; "source": { "alias": "source"; "required": false; }; "template": { "alias": "template"; "required": false; }; "collapseSize": { "alias": "collapseSize"; "required": false; }; "tabbable": { "alias": "tabbable"; "required": false; }; }, { "selected": "selected"; "cleared": "cleared"; }, never, ["*"], true, never>;
}

/**
 * This component will allow the developer to modify any DOM element
 * by exposing it (if desired)
 */
declare class SohoListViewSearchComponent {
    /**
     * Use this flag if you are projecting a soho-searchfield into this component
     * from another component and do not want this component to build another
     * searchfield
     */
    buildSearch: boolean;
    get isListviewSearch(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewSearchComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListViewSearchComponent, "[soho-listview-search]", never, { "buildSearch": { "alias": "buildSearch"; "required": false; }; }, {}, never, ["span[soho-searchfield-wrapper]", "input[soho-searchfield]", "*"], true, never>;
}
declare class SohoListViewItemComponent implements AfterViewInit {
    element: ElementRef;
    /** Underling jQuery item. */
    private listItem?;
    /** Sets the item as disabled.  */
    disabled: boolean;
    /** Sets the item as selected.  */
    selected: boolean;
    /**
     * Constructor.
     *
     * @param element - the element.
     */
    constructor(element: ElementRef);
    /**
     * The index of the list view item in it's parent.
     */
    get index(): number | undefined;
    get selector(): JQuery<HTMLElement> | undefined;
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListViewItemComponent, "[soho-listview-item]", never, { "disabled": { "alias": "disabled"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class SohoListViewHeaderComponent {
    get isHeading(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListViewHeaderComponent, "[soho-listview-header]", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoListViewSubHeaderComponent {
    get isSubHeading(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewSubHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListViewSubHeaderComponent, "[soho-listview-subheader]", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoListViewMicroComponent {
    get isMicro(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewMicroComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListViewMicroComponent, "[soho-listview-micro]", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoListViewComponent implements AfterViewInit, OnDestroy, AfterViewChecked {
    private ngZone;
    items?: QueryList<SohoListViewItemComponent>;
    /**
     * String of classes to append to the class for the list-view div element
     */
    class?: string;
    sohoListviewElementId?: string;
    /**
     * Force a update to fire next viewChecked.
     */
    updateRequired?: boolean;
    /**
     * Array of data
     */
    set dataset(value: Object[] | undefined);
    get dateset(): Object[] | undefined;
    /** Audible Label (or use parent title). */
    set description(value: string);
    /** If paging is activated, sets the number of listview items available per page. */
    set pagesize(value: number);
    /** If true, activates paging. */
    set paging(value: boolean);
    /** If true, associates itself with a Searchfield/Autocomplete and allows itself to be filtered.  */
    set searchable(value: boolean | undefined);
    get searchable(): boolean | undefined;
    /** false, 'single', or 'multiple'. */
    set selectable(value: SohoListViewSelectable);
    /** Select on focus change?true or false. */
    set selectOnFocus(value: boolean);
    /** External function that can be used to provide an empty  message when no data is available. */
    set emptyMessage(value: SohoEmptyMessageOptions);
    /** External function that can be used to provide a datasource, or a URL. */
    set source(value: SohoListViewSourceFunction | string);
    /** Html Template String. */
    set template(value: string);
    set disableItemDeactivation(value: boolean | undefined);
    get disableItemDeactivation(): boolean | undefined;
    set allowDeselect(value: boolean | undefined);
    get allowDeselect(): boolean | undefined;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /** Reveal text settings for masking/revealing text content */
    set revealTextSettings(value: SohoListViewRevealableTextData | undefined);
    get revealTextSettings(): SohoListViewRevealableTextData | undefined;
    /**
     * Set the list of selected items either by their indices or via the
     * jQuery selector for the li element.
     *
     * @param selectedItems the list of selected items.
     * @throws Error if any of the indicies are out of bounds.
     */
    set selectedItems(selectedItems: SohoListViewItemReference[]);
    /**
     * Selected List Items.
     *
     * Note currenty this returns the index of the selected item.
     *
     * @return the indexes of the selected list items.
     */
    get getSelectedItems(): SohoListViewItemReference[] | undefined;
    /**
     * Called after the listview is rendered, passes the dataset
     */
    rendered: EventEmitter<Object[]>;
    /**
     * Called before an item is selected. Return false to prevent selection.
     */
    beforeSelectCallback?: (event: any, args: any[]) => boolean | void;
    /**
     * Called before an item is deselected. Return false to prevent deselection.
     */
    beforeDeselectCallback?: (event: any, args: any[]) => boolean | void;
    /**
     * Called before an item is selected. Returns an object containing the event and the
     * current selected items.
     */
    beforeselect: EventEmitter<Object>;
    /**
     * Called before an item is deselected. Returns an object containing the event and the
     * current selected items.
     */
    beforedeselect: EventEmitter<Object>;
    /**
     * Called once an item is selected. Returns an object containing the event and the
     * current selected items.
     */
    selected: EventEmitter<Object>;
    /**
     * Called once an item is deselected. Returns an object containing the event and the
     * current selected items.
     */
    unselected: EventEmitter<Object>;
    /**
     * Called once an item is deselected. Returns an object containing the event and the
     * current selected items.
     */
    deselected: EventEmitter<Object>;
    /**
     * Called once an item is activated. Returns an object containing the event
     * and additional info about the activated item.
     */
    itemactivated: EventEmitter<Object>;
    /**
     * Called once an item is deactivated.  Returns an object containing the event
     * and additional info about the deactivated item.
     */
    itemdeactivated: EventEmitter<Object>;
    /**
     * Called once an item is clicked. You may also prefer need activated / deactived here.
     */
    click: EventEmitter<Object>;
    /**
     * Called once an item is double clicked. This isnt used that often.
     */
    dblclick: EventEmitter<Object>;
    /**
     * Called during right click to enable context menus on list items.
     * Use popupmenu during this event.
     */
    contextmenu: EventEmitter<Object>;
    /**
     * Called after the list has been sorted for any reason
     */
    sorted: EventEmitter<Object[]>;
    listViewRef: ElementRef | undefined;
    searchfieldRef?: SohoSearchFieldComponent;
    /**
     * Local variables
     */
    private jQueryElement?;
    private listview?;
    private options;
    /**
     * Constructor.
     */
    constructor(ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    get listClass(): string;
    /**
     * Clear all the currently selected listview items that are selected.
     */
    clearAllSelected(): void;
    /**
     * Toggle the selected listview items between all and none.
     */
    toggleAll(): void;
    /**
     * Removes the list item (or list items) identified by their index or jQuery element.
     *
     * @param index - the index (or list of indices) of the items to be removed.
     * @throws Error if the argument is null, or contains out of range indices then any error is thrown.
     */
    remove(index: SohoListViewItemReference | SohoListViewItemReference[]): void;
    /**
     * Unselects the list item (or list items) identified by their index or jQuery element.
     *
     * @param index - the index (or list of indices) of the items to be unselected.
     * @throws Error if the argument is null, or contains out of range indices then any error is thrown.
     */
    unselect(index: SohoListViewItemReference | SohoListViewItemReference[]): void;
    /**
     * Selects the list item (or list items) identified by their index or jQuery element.
     *
     * If the argument is null, or contains out of range indices then any error is thrown.
     *
     * @param index the index (or list of indices) of the items to be deselected.
     * @throws Error if the argument is null, or contains out of range indices then any error is thrown.
     */
    select(index: SohoListViewItemReference | SohoListViewItemReference[]): void;
    /**
     * Activate the given list item.
     */
    activateItem(item: SohoListViewItemReference): void;
    /**
     * Return an object containing info about the currently activated item.
     */
    activatedItem(): any;
    /**
     * De-activate the given list item. If no item is specified the currently
     * activated item will be deactivated.
     */
    deactivateItem(item?: SohoListViewItemReference): void;
    /**
     * Toggle Activation on the given list item.
     */
    toggleItemActivation(item: SohoListViewItemReference): void;
    /**
     * Apply the given function to the list view item(s).
     *
     * @param fn the function to apply - must take a SohoListViewReference.
     * @param index the index of list view item(s).
     */
    private apply;
    /**
     * Verifies the given item reference is within allowable ranges.
     */
    private boundsCheck;
    /**
     * The number of items in the list.
     */
    private get itemCount();
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListViewComponent, "soho-listview", never, { "class": { "alias": "class"; "required": false; }; "sohoListviewElementId": { "alias": "sohoListviewElementId"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "description": { "alias": "description"; "required": false; }; "pagesize": { "alias": "pagesize"; "required": false; }; "paging": { "alias": "paging"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "selectOnFocus": { "alias": "selectOnFocus"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "source": { "alias": "source"; "required": false; }; "template": { "alias": "template"; "required": false; }; "disableItemDeactivation": { "alias": "disableItemDeactivation"; "required": false; }; "allowDeselect": { "alias": "allowDeselect"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "revealTextSettings": { "alias": "revealTextSettings"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; "beforeSelectCallback": { "alias": "beforeSelectCallback"; "required": false; }; "beforeDeselectCallback": { "alias": "beforeDeselectCallback"; "required": false; }; }, { "rendered": "rendered"; "beforeselect": "beforeselect"; "beforedeselect": "beforedeselect"; "selected": "selected"; "unselected": "unselected"; "deselected": "deselected"; "itemactivated": "itemactivated"; "itemdeactivated": "itemdeactivated"; "click": "click"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; "sorted": "sorted"; }, ["searchfieldRef", "items"], ["input[soho-searchfield]", "div.[soho-listview-search]", "soho-toolbar.contextual-toolbar,div.[soho-toolbar].contextual-toolbar", "li[soho-listview-item]", "[soho-emptymessage]"], true, never>;
}

declare class SohoListViewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListViewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoListViewModule, never, [typeof SohoListViewComponent, typeof SohoListViewHeaderComponent, typeof SohoListViewItemComponent, typeof SohoListViewMicroComponent, typeof SohoListViewSearchComponent, typeof SohoListViewSubHeaderComponent], [typeof SohoListViewComponent, typeof SohoListViewHeaderComponent, typeof SohoListViewItemComponent, typeof SohoListViewMicroComponent, typeof SohoListViewSearchComponent, typeof SohoListViewSubHeaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoListViewModule>;
}

declare class SohoListBuilderComponent implements AfterViewInit, OnDestroy, AfterViewChecked {
    private ngZone;
    get isListbuilder(): boolean;
    /**
     * Local variables
     */
    private jQueryElement?;
    private listbuilder?;
    private options;
    /**
    * Force a update to fire next viewChecked.
    */
    updateRequired?: boolean;
    /**
     * Constructor.
     */
    constructor(ngZone: NgZone);
    listBuilderRef: ElementRef | undefined;
    sohoListBuilderElementId?: string;
    /**
     * String of classes to append to the class for the list-view div element
     */
    class?: string;
    get listClass(): string;
    /**
     * Array of data
     */
    set dataset(value: Object[] | undefined);
    get dataset(): Object[] | undefined;
    /** The CSS Class of the handle element */
    set handle(value: string);
    /** "Add" action button (takes a string representing a "data-action" attribute */
    set btnAdd(value: string);
    /** "Edit" action button (takes a string representing a "data-action" attribute */
    set btnEdit(value: string);
    /** "Delete" action button (takes a string representing a "data-action" attribute */
    set btnDelete(value: string);
    /** "GoUp" action button (takes a string representing a "data-action" attribute */
    set btnGoUp(value: string);
    /** "GoDown" action button (takes a string representing a "data-action" attribute */
    set btnGoDown(value: string);
    /** Add extra attributes like id's to the chart elements. For example `attributes: { name: 'id', value: 'my-unique-id' } */
    set attributes(attributes: Array<Object> | Object | undefined);
    /** Html Template String of list. */
    set template(value: string);
    /** Html Template String of list item. */
    set templateNewItem(value: string);
    /** Html Template String of list item inner content. */
    set templateItemContent(value: string);
    /** When true, hides the entire toolbar and removes the space it occupies. */
    set hideToolbar(value: boolean);
    get hideToolbar(): boolean;
    /** When set, clears all existing buttons from the toolbar's buttonset and rebuilds them in the specified order.
     * Valid values: 'add', 'up', 'down', 'edit', 'delete', 'separator'. */
    set buttons(value: string[] | undefined);
    get buttons(): string[] | undefined;
    /** When set, excludes the specified buttons from the toolbar.
     * Valid values: 'add', 'up', 'down', 'edit', 'delete'. */
    set excludeButtons(value: string[] | undefined);
    get excludeButtons(): string[] | undefined;
    /** Calls events after a top button action */
    afteradd: EventEmitter<Object[]>;
    aftergoup: EventEmitter<Object[]>;
    aftergodown: EventEmitter<Object[]>;
    afterdelete: EventEmitter<Object[]>;
    /** Calls events before a top button action */
    beforeedit: EventEmitter<Object[]>;
    beforeadd: EventEmitter<Object[]>;
    beforegoup: EventEmitter<Object[]>;
    beforegodown: EventEmitter<Object[]>;
    beforedelete: EventEmitter<Object[]>;
    /** Update event on arranging items (drag and drop item) */
    arrangeupdate: EventEmitter<Object[]>;
    /** Calls events for edit item */
    entereditmode: EventEmitter<Object[]>;
    exiteditmode: EventEmitter<Object[]>;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListBuilderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoListBuilderComponent, "[soho-listbuilder]", never, { "sohoListBuilderElementId": { "alias": "sohoListBuilderElementId"; "required": false; }; "class": { "alias": "class"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "handle": { "alias": "handle"; "required": false; }; "btnAdd": { "alias": "btnAdd"; "required": false; }; "btnEdit": { "alias": "btnEdit"; "required": false; }; "btnDelete": { "alias": "btnDelete"; "required": false; }; "btnGoUp": { "alias": "btnGoUp"; "required": false; }; "btnGoDown": { "alias": "btnGoDown"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "template": { "alias": "template"; "required": false; }; "templateNewItem": { "alias": "templateNewItem"; "required": false; }; "templateItemContent": { "alias": "templateItemContent"; "required": false; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "excludeButtons": { "alias": "excludeButtons"; "required": false; }; }, { "afteradd": "afteradd"; "aftergoup": "aftergoup"; "aftergodown": "aftergodown"; "afterdelete": "afterdelete"; "beforeedit": "beforeedit"; "beforeadd": "beforeadd"; "beforegoup": "beforegoup"; "beforegodown": "beforegodown"; "beforedelete": "beforedelete"; "arrangeupdate": "arrangeupdate"; "entereditmode": "entereditmode"; "exiteditmode": "exiteditmode"; }, never, ["li[soho-listview-item]", "[soho-emptymessage]"], true, never>;
}

declare class SohoListBuilderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoListBuilderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoListBuilderModule, never, [typeof SohoListBuilderComponent], [typeof SohoListBuilderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoListBuilderModule>;
}

declare class SohoFormatDatePipe implements PipeTransform {
    /**
     * Formats the given date using the soho locale formats.
     *
     * @param value the date (or string), must not be null.
     * @param attribs optional, additional formatting settings.
     * @returns the translated resource string or undefined.
     *
     */
    transform(value: string | Date, attribs?: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFormatDatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SohoFormatDatePipe, "sohoFormatDate", true>;
}

declare class SohoFormatNumberPipe implements PipeTransform {
    /**
     * Formats the given date using the soho locale formats.
     *
     * @param value the date (or string), must not be null.
     * @param attribs optional, additional formatting settings.
     * @returns the translated resource string or undefined.
     *
     */
    transform(value: string | number, attribs?: any): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoFormatNumberPipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SohoFormatNumberPipe, "sohoFormatNumber", true>;
}

declare class SohoTranslatePipe implements PipeTransform {
    /**
     * Translates the specified string into the current locale.
     *
     * @param value the resource string, must not be null.
     * @param locale the locale to use, defaults to current locale.
     * @param options additional options passed to the locale translate function
     * @returns the translated resource string or undefined.
     *
     */
    transform(value: string, locale?: string | undefined, options?: Object | undefined): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTranslatePipe, never>;
    static ɵpipe: i0.ɵɵPipeDeclaration<SohoTranslatePipe, "sohoTranslate", true>;
}

declare class SohoLocaleModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLocaleModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoLocaleModule, never, [typeof SohoFormatDatePipe, typeof SohoFormatNumberPipe, typeof SohoTranslatePipe], [typeof SohoTranslatePipe, typeof SohoFormatDatePipe, typeof SohoFormatNumberPipe]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoLocaleModule>;
}

declare class ArgumentHelper {
    /**
     * Checks the given parameter is not null, throws an exception if not.
     */
    static checkNotNull(parameterName: string, arg: any): void;
    static checkNotEmpty(parameterName: string, arg: string): void;
    static checkInputNotNull(parentName: string, inputName: string, arg: any): void;
    static checkChildNotNull(parentName: string, childName: string, arg: any): void;
}

declare class DeprecatedEventEmitter<T> extends EventEmitter<T> {
    private deprecatedName;
    private newName;
    constructor(deprecatedName: string, newName: string);
    subscribe(generatorOrNext?: any, error?: any, complete?: any): Subscription;
}

declare class SohoIconUtils {
    /**
     * Returns the RAW HTML for creating a new icon in string form
     */
    static createIcon(params: any): string;
    /**
     * Returns a jQuery-wrapped element containing a new icon
     */
    static createIconElement(options: any): JQuery;
    /**
     * Returns just the path part
     */
    static createIconPath(options: any): string;
}

/**
 * Static helper class for common test functionality
 */
declare class TestHelper {
    /**
     * Fire a soho or dom event where it's expected to be re-emitted by the passed in event emitter
     *
     * @param element The native element where the dom event is triggered from.
     * @param eventName The name of the event to trigger on the native element.
     * @param eventEmitter The angular event emitter that will be checked toHaveBeenCalled 1 time.
     */
    static testFireEvent(element: HTMLElement, eventName: string, eventEmitter: EventEmitter<any>): void;
}

declare class SohoLookupComponent extends BaseControlValueAccessor<any> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /**
     * Used to call updated from the afterViewChecked lifecycle event.
     */
    private updateRequired?;
    /**
     * API for interacting with modal and then in turn the buttons on the dialog.
     */
    modal?: SohoModalStatic;
    /**
     * Available Soho Template control settings as Inputs
     * Should match the Soho properties for the component
     */
    asobject: boolean;
    /** Grid columns. */
    columns?: SohoDataGridColumn[];
    /**
     * Changes the dataset being used
     */
    set dataset(data: Object[] | undefined);
    get dataset(): Object[] | undefined;
    /** Custom click event; can be used with a modal dialog and custom list component */
    set click(value: SohoLookupClickFunction | undefined);
    get click(): SohoLookupClickFunction | undefined;
    /** If a click method is defined, this flexible object can be passed in. */
    set clickArguments(value: any);
    get clickArguments(): any;
    /** Custom clear event; can be used with a modal dialog and custom list component */
    set clear(value: SohoLookupClearFunction | undefined);
    get clear(): SohoLookupClearFunction | undefined;
    /** If a clear method is defined, this flexible object can be passed in. */
    set clearArguments(value: any);
    get clearArguments(): any;
    /** Field to return from the array or can be a function. */
    set field(value: string | SohoLookupFieldFunction | undefined);
    get field(): string | SohoLookupFieldFunction | undefined;
    /** Dialog title or takes the label + Lookup. */
    set title(value: string | undefined);
    get title(): string | undefined;
    /** Swap out the lookup id for any other icon in the icon set by name */
    set icon(value: string | undefined);
    get icon(): string | undefined;
    /** Pass dialog buttons or Cancel / Apply. */
    set buttons(value: SohoModalButton[] | undefined);
    get buttons(): SohoModalButton[] | undefined;
    /** Options to pass to the underlying data grid. */
    set options(value: SohoDataGridOptions | undefined);
    get options(): SohoDataGridOptions | undefined;
    /**
     * Used to manage data prior to showing the lookup.
     *
     * For example:
     *  - When the button is clicked, show a loading dialog and make the request for
     *    lookup grid data.
     *  - Upon receiving grid data, set lookup.settings.options for the columns and dataset.
     *  - Then call grid() to build the grid and complete the lookup call.
     */
    set beforeShow(value: SohoLookupBeforeShowFunction | undefined);
    get beforeShow(): SohoLookupBeforeShowFunction | undefined;
    /** Custom modal content. */
    set modalContent(value: JQuery | string | undefined);
    get modalContent(): JQuery | string | undefined;
    /** Can the user type random text into the field. */
    set editable(value: boolean | undefined);
    get editable(): boolean | undefined;
    /** If set to false the dialog wont apply the value on clicking a value. */
    set autoApply(value: boolean | undefined);
    get autoApply(): boolean | undefined;
    /** Function used to match the search term to the data. */
    set match(value: SohoDataGridMatchFunction | undefined);
    get match(): SohoDataGridMatchFunction | undefined;
    /** A function that fires to let you validate form items on open and select. */
    set validator(value: SohoLookupValidatorFunction | undefined);
    get validator(): SohoLookupValidatorFunction | undefined;
    /** Set the width of the input to the width of the selection */
    set autoWidth(value: boolean | undefined);
    get autoWidth(): boolean | undefined;
    /** The character  used to separate data strings */
    set delimiter(value: string | undefined);
    get delimiter(): string | undefined;
    /** Apply a minimum width to the lookup*/
    set minWidth(value: number | undefined);
    get minWidth(): number | undefined;
    /**  Add an ability to clear the lookup field with an x */
    set clearable(value: boolean | undefined);
    get clearable(): boolean | undefined;
    /**  Add extra attributes like id's to the component */
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /**  Set the input to tabbable */
    set tabbable(tabbable: boolean | undefined);
    get tabbable(): boolean | undefined;
    /** Set `no-margin` class to lookup wrapper */
    set noMarginWrapper(noMarginWrapper: boolean | undefined);
    get noMarginWrapper(): boolean | undefined;
    /**  Set custom CSS classes for lookup */
    set cssClass(cssClass: string | undefined);
    get cssClass(): string | undefined;
    /**  Set the input to allow duplicates */
    set allowDuplicates(allowDuplicates: boolean | undefined);
    get allowDuplicates(): boolean | undefined;
    toolbarPlaceholder?: string;
    multiselect: boolean;
    name?: string;
    source?: SohoDataGridSourceFunction;
    toolbar?: SohoToolbarOptions;
    autoCompleteSettings?: SohoLookupAutoComplete;
    /**
     * Available Soho Template events as Output (EventEmitters passing the event)
     * Should match the Soho event names for the component
     */
    afteropen: EventEmitter<Object>;
    start: EventEmitter<Object>;
    complete: EventEmitter<Object>;
    beforeopen: EventEmitter<Object>;
    change: EventEmitter<SohoLookupChangeEvent[]>;
    inputEvt: EventEmitter<Object>;
    open: EventEmitter<Object>;
    close: EventEmitter<Object>;
    selected: EventEmitter<Object>;
    afterpaging: EventEmitter<Object>;
    /**
     * Bind attributes to the host input element
     */
    get isLookup(): boolean;
    /**
     * Is the lookup control disabled?
     */
    _disabled: boolean | undefined;
    /**
     * Accessor for _disabled.
     */
    get isDisabled(): boolean | undefined;
    set isDisabled(disabled: boolean | undefined);
    /**
     * Add class binding.
     */
    get disabledClass(): boolean | undefined;
    /**
     * Is the lookup control readonly?
     */
    _readonly: boolean | undefined;
    /**
     * Local variables
     */
    private jQueryElement?;
    /**
     * Soho Lookup widget.
     *
     * @private
     */
    private lookup?;
    /**
     * Autocomplete
     */
    private autocomplete;
    private settings;
    /** Initial dataset */
    private _dataset?;
    /**
     * Constructor.
     *
     * @param element associated element
     * @param ngZone angular zone
     */
    constructor(element: ElementRef, ngZone: NgZone);
    onKeyUp(_event: KeyboardEvent): void;
    ngAfterViewInit(): void;
    /**
     * Update the selected rows
     */
    updateSelectedRows(rows: any[]): void;
    /**
     * Find the row and select it based on select value / function / field value
     */
    selectRowByValue(field: String, value: String): void;
    /** Get the selected rows and return them to the UI **/
    insertRows(): void;
    /** Returns the rows currently selected **/
    selectedRows(): any[];
    /** Enable the input. **/
    enable(): void;
    /** Disable the input. **/
    disable(): void;
    /** Make the input readonly. **/
    readonly(): void;
    /**  Send in a new data set to display in the datagrid in the lookup. **/
    updateDataset(dataset: Object[], pagerInfo: SohoPagerPagingInfo): void;
    /**
     * Call to notify the lookup about any dom/settings changes
     */
    updated(settings?: any): void;
    /**
     * Sets the loading/busy indicator state for the modal element.
     */
    setLoadingIndicator(show: boolean, options?: SohoBusyIndicatorOptions): void;
    /**
     * Destroys the modal lookup.
     */
    destroy(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    isMultiselect(): boolean | undefined;
    modalOpened(args: any[]): void;
    /**
     * Handle the control being changed.
     */
    onChange(event: SohoLookupChangeEvent[]): void;
    onAutocompleteChange(event: any): void;
    onAutocompleteSelected(event: any): void;
    onAutocompleteBeforeOpen(event: any): void;
    setDisabledState(isDisabled: boolean | undefined): void;
    /**
     * Needed to extract this function from the 'insertRows' function within the
     * Soho Lookup control object.
     * TODO: Expose this in the Sohoxi library @tim @ed.coyle
     *
     * @todo raise SOHO jira issue
     */
    processValue(value: Object | Object[]): string;
    /**
     * Set lookup value to allow the lookup element to be updated correctly.
     * Used when the click property is set on the sohoxi control.
     *
     * @param event - selected row
     * TODO: Expose this in the Sohoxi library @tim @ed.coyle
     *
     * @todo raise SOHO jira issue
     */
    setValue(event: SohoLookupChangeEvent[]): void;
    /**
     * Override writeValue to allow the lookup
     * element to be updated correctly.
     *
     * @param value - the new value
     */
    writeValue(value: any): void;
    /**
     * Evaluate the event param and parse the value
     */
    private parseValue;
    private markForUpdate;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLookupComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoLookupComponent, "input[soho-lookup]", never, { "asobject": { "alias": "asobject"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "click": { "alias": "click"; "required": false; }; "clickArguments": { "alias": "clickArguments"; "required": false; }; "clear": { "alias": "clear"; "required": false; }; "clearArguments": { "alias": "clearArguments"; "required": false; }; "field": { "alias": "field"; "required": false; }; "title": { "alias": "title"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "buttons": { "alias": "buttons"; "required": false; }; "options": { "alias": "options"; "required": false; }; "beforeShow": { "alias": "beforeShow"; "required": false; }; "modalContent": { "alias": "modalContent"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "autoApply": { "alias": "autoApply"; "required": false; }; "match": { "alias": "match"; "required": false; }; "validator": { "alias": "validator"; "required": false; }; "autoWidth": { "alias": "autoWidth"; "required": false; }; "delimiter": { "alias": "delimiter"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "tabbable": { "alias": "tabbable"; "required": false; }; "noMarginWrapper": { "alias": "noMarginWrapper"; "required": false; }; "cssClass": { "alias": "cssClass"; "required": false; }; "allowDuplicates": { "alias": "allowDuplicates"; "required": false; }; "toolbarPlaceholder": { "alias": "toolbarPlaceholder"; "required": false; }; "multiselect": { "alias": "multiselect"; "required": false; }; "name": { "alias": "name"; "required": false; }; "source": { "alias": "source"; "required": false; }; "toolbar": { "alias": "toolbar"; "required": false; }; "autoCompleteSettings": { "alias": "autoCompleteSettings"; "required": false; }; "isDisabled": { "alias": "disabled"; "required": false; }; "_readonly": { "alias": "readonly"; "required": false; }; }, { "afteropen": "afteropen"; "start": "start"; "complete": "complete"; "beforeopen": "beforeopen"; "change": "change"; "inputEvt": "inputEvt"; "open": "open"; "close": "close"; "selected": "selected"; "afterpaging": "afterpaging"; }, never, ["*"], true, never>;
}

declare class SohoLookupModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoLookupModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoLookupModule, never, [typeof SohoLookupComponent], [typeof SohoLookupComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoLookupModule>;
}

declare class SohoMaskDirective implements AfterViewInit, OnDestroy {
    private element;
    /** Private control options. */
    private _options;
    private _patternOptions;
    private _symbols;
    /** Sets all the options. */
    set options(value: SohoMaskOptions | string);
    /** Definitions of pattern(s) as a regular expression. */
    set definitions(value: {
        [key: string]: RegExp;
    });
    /** When true, appends the leftover characters in the placeholder to the conformed value. */
    set guide(value: boolean);
    /** When true, keeps groups of character intact. */
    set keepCharacterPositions(value: boolean);
    /** Function that replaces the internal masking functionality. */
    set maskAPI(value: Function);
    /**
     *  The pattern to use for the mask.
     *
     * This uses the sohoPrefix otherwise the pattern interferes
     * with the pattern on form groups.
     */
    set sohoPattern(value: SohoMaskPattern);
    /** Function that is executed after the masking process is complete. */
    set pipe(value: Function);
    /** The placeholder text for the mask. */
    set placeholder(value: string);
    /** The placeholder character for the mask. */
    set placeholderChar(value: string);
    /** Indicates special formatting rules may apply to the mask. */
    set process(value: SohoMaskProcess);
    /** When true, the onblur event executes mask processing. */
    set processOnBlur(value: boolean);
    /** Indicates to initially mask the value of the input field. */
    set processOnInitialize(value: boolean);
    /** The pattern options. */
    set patternOptions(value: SohoMaskPatternOptions | string);
    /** When true, the decimal separator symbol is allowed in a formatted number. */
    set allowDecimal(value: boolean);
    /** When true, allows leading zeros in a formatted number. */
    set allowLeadingZeros(value: boolean);
    /** When true, the negative symbol is allowed in a formatted number. */
    set allowNegative(value: boolean);
    /** When true, adds the thousands separator symbol to the correct location in a formatted number. */
    set allowThousandsSeparator(value: boolean);
    /** The maximum number of digits to the left of the decimal separator symbol in a formatted number. */
    set decimalLimit(value: number);
    /** Shows trailing decimal zeroes in a formatter number. */
    set allowTrailingDecimalZeros(value: number);
    /** The maximum number of digits to the right of decimal separator symbol in a formatted number. */
    set integerLimit(value: number);
    /** The character that precedes the masked value. */
    set prefix(value: string);
    /** When true, the decimal separator symbol is required in a formatted number. */
    set requireDecimal(value: boolean);
    /** The character that follows the masked value. */
    set suffix(value: string);
    /** The symbols to use for the formatted number. */
    set symbols(value: SohoMaskPatternSymbols | string);
    /** The locale to use for the formatted number. */
    set locale(value: string);
    /** The currency symbol to use for the formatted number. */
    set currencySymbol(value: string);
    /** The decimal separator symbol to use for the formatted number. */
    set decimalSymbol(value: string);
    /** The negative symbol to use for the formatted number. */
    set negativeSymbol(value: string);
    /** The thousands separator symbol to use for the formatted number. */
    set thousandsSymbol(value: string);
    /**
     * Indicates if each section of the group pattern match must be full in order for
     * the literals in-between each section to be automatically added (meaning you can't
     * type a literal to end that group until all characters in that group are entered).
     *
     * @deprecated not supported
     */
    set groupComplete(_value: boolean);
    /**
     * Indicates special formatting rules may apply to the mask.
     *
     * @deprecated use process instead
     */
    set mode(value: SohoMaskMode);
    /**
     * Indicates to complete the full mask or the mask will revert to empty.
     *
     * @deprecated not supported
     */
    set mustComplete(_value: boolean);
    /**
     * Indicates you can enter the negative symbol in front of the number;
     * automatically set to true if a negative symbol is detected inside the mask.
     *
     * @deprecated use allowNegative instead
     */
    set negative(value: boolean);
    /**
     * Option defined in control, but not referenced.
     *
     * @deprecated
     */
    set number(_value: boolean);
    /**
     * Indicates the thousands separator for numbers (based on localization) will be
     * inserted wherever necessary during typing; automatically set to true if the
     * localized thousands separator is detected inside the mask.
     *
     * @deprecated use allowThousandsSeparator instead
     */
    set thousandsSeparator(value: boolean);
    /**
     * Indicates to display the localized symbol for currency or percent;
     * backwards compatible with old 'data-show-currency'; value true equates to currency
     *
     * @deprecated use prefix or suffix instead
     */
    set showSymbol(_value: SohoMaskShowSymbol);
    /**
     * Called when mask value changes
     */
    write: EventEmitter<SohoMaskEvent>;
    /**
     * Local variables
     */
    private jQueryElement?;
    private mask?;
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    /** Destructor. */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMaskDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoMaskDirective, "input[soho-mask]", never, { "options": { "alias": "options"; "required": false; }; "definitions": { "alias": "definitions"; "required": false; }; "guide": { "alias": "guide"; "required": false; }; "keepCharacterPositions": { "alias": "keepCharacterPositions"; "required": false; }; "maskAPI": { "alias": "maskAPI"; "required": false; }; "sohoPattern": { "alias": "sohoPattern"; "required": false; }; "pipe": { "alias": "pipe"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "placeholderChar": { "alias": "placeholderChar"; "required": false; }; "process": { "alias": "process"; "required": false; }; "processOnBlur": { "alias": "processOnBlur"; "required": false; }; "processOnInitialize": { "alias": "processOnInitialize"; "required": false; }; "patternOptions": { "alias": "patternOptions"; "required": false; }; "allowDecimal": { "alias": "allowDecimal"; "required": false; }; "allowLeadingZeros": { "alias": "allowLeadingZeros"; "required": false; }; "allowNegative": { "alias": "allowNegative"; "required": false; }; "allowThousandsSeparator": { "alias": "allowThousandsSeparator"; "required": false; }; "decimalLimit": { "alias": "decimalLimit"; "required": false; }; "allowTrailingDecimalZeros": { "alias": "allowTrailingDecimalZeros"; "required": false; }; "integerLimit": { "alias": "integerLimit"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "requireDecimal": { "alias": "requireDecimal"; "required": false; }; "suffix": { "alias": "suffix"; "required": false; }; "symbols": { "alias": "symbols"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "currencySymbol": { "alias": "currencySymbol"; "required": false; }; "decimalSymbol": { "alias": "decimalSymbol"; "required": false; }; "negativeSymbol": { "alias": "negativeSymbol"; "required": false; }; "thousandsSymbol": { "alias": "thousandsSymbol"; "required": false; }; "groupComplete": { "alias": "groupComplete"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "mustComplete": { "alias": "mustComplete"; "required": false; }; "negative": { "alias": "negative"; "required": false; }; "number": { "alias": "number"; "required": false; }; "thousandsSeparator": { "alias": "thousandsSeparator"; "required": false; }; "showSymbol": { "alias": "showSymbol"; "required": false; }; }, { "write": "write"; }, never, never, true, never>;
}

declare class SohoMaskModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMaskModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoMaskModule, never, [typeof SohoMaskDirective], [typeof SohoMaskDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoMaskModule>;
}

declare class SohoMastheadComponent {
    get classes(): string;
    ariaLabel: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMastheadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoMastheadComponent, "soho-masthead", never, { "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, ["soho-masthead-title", "soho-masthead-buttonset"], true, never>;
}

declare class SohoMastheadModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMastheadModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoMastheadModule, never, [typeof SohoMastheadComponent], [typeof SohoMastheadComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoMastheadModule>;
}

declare class SohoMenuButtonComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ref;
    private ngZone;
    get isBtnMenu(): boolean;
    get buttonType(): string;
    /** The underlying jQuery instance. */
    private jQueryElement?;
    /** The enterprise widget api. */
    private menuButton?;
    /** The button widget api */
    private button?;
    private options;
    private buttonOptions;
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    selected: EventEmitter<SohoContextMenuEvent>;
    beforeopen: EventEmitter<SohoContextMenuEvent>;
    /**
     * @todo remove override of native element
     */
    open$: EventEmitter<SohoContextMenuEvent>;
    /**
     * @todo remove override of native element
     */
    close$: EventEmitter<SohoContextMenuEvent>;
    /** The icon to be used. */
    icon?: string;
    set autoFocus(value: boolean);
    set mouseFocus(value: boolean);
    set showArrow(value: boolean);
    set returnFocus(value: boolean);
    get returnFocus(): boolean;
    set trigger(trigger: SohoPopupMenuTrigger);
    set menu(menu: string | JQuery<HTMLElement>);
    set ajaxBeforeOpenFunction(fn: AjaxBeforeOpenFunction);
    set hideMenuArrow(value: boolean | undefined);
    get hideMenuArrow(): boolean | undefined;
    set offset(value: SohoPopupmenuOffset | undefined);
    get offset(): SohoPopupmenuOffset | undefined;
    set attachToBody(value: boolean | undefined);
    get attachToBody(): boolean | undefined;
    set removeOnDestroy(value: boolean | undefined);
    get removeOnDestroy(): boolean | undefined;
    set ripple(value: boolean | undefined);
    get ripple(): boolean | undefined;
    /** If true, the menu stays open when clicking outside or pressing Escape/Tab */
    set keepOpen(value: boolean | undefined);
    get keepOpen(): boolean | undefined;
    constructor(element: ElementRef, ref: ChangeDetectorRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    private onSelected;
    private onBeforeOpen;
    private onClose;
    private onOpen;
    updated(menuSettings?: SohoPopupMenuOptions, buttonSettings?: SohoButtonOptions): void;
    teardown(): void;
    close(): void;
    open(event: JQuery.TriggeredEvent, ajaxReturn?: boolean, useDelay?: boolean): void;
    ngOnDestroy(): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMenuButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoMenuButtonComponent, "[soho-menu-button]", never, { "icon": { "alias": "icon"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "mouseFocus": { "alias": "mouseFocus"; "required": false; }; "showArrow": { "alias": "showArrow"; "required": false; }; "returnFocus": { "alias": "returnFocus"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "ajaxBeforeOpenFunction": { "alias": "ajaxBeforeOpenFunction"; "required": false; }; "hideMenuArrow": { "alias": "hideMenuArrow"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "attachToBody": { "alias": "attachToBody"; "required": false; }; "removeOnDestroy": { "alias": "removeOnDestroy"; "required": false; }; "ripple": { "alias": "ripple"; "required": false; }; "keepOpen": { "alias": "keepOpen"; "required": false; }; }, { "selected": "selected"; "beforeopen": "beforeopen"; "open$": "open"; "close$": "close"; }, never, ["*"], true, never>;
}

declare class SohoMenuButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMenuButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoMenuButtonModule, never, [typeof SohoMenuButtonComponent], [typeof SohoMenuButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoMenuButtonModule>;
}

declare class SohoMessageModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMessageModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoMessageModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoMessageModule>;
}

/**
 * Wrapper for the jQuery modal control.
 */
declare class SohoMessageRef {
    /** Vetoable Event Guard */
    private eventGuard;
    /** Selector referencing the modal-dialog after it has been moved to the dialog container. */
    private jQueryElement?;
    /** Soho Control Api */
    private _message?;
    /** The result of the dialog. */
    private _dialogResult;
    /** Dialog placeholder, defaults to $('body')*/
    private _placeholder;
    /** Event fired when the message is opened. */
    private open$;
    /**
     * Cached options.
     */
    private _options;
    /**
     * Sets the whole options block for this modal dialog.
     *
     * @param options - the options to set.
     */
    options(options?: SohoMessageOptions): SohoMessageRef;
    /**
     * Sets the width for the dialog.
     *
     * @param width - the extra frame height to allow.
     */
    frameHeight(width: number): SohoMessageRef;
    /**
     * Sets the title of the message dialog.
     *
     * @param title - the title of the dialog.
     */
    title(title: string): SohoMessageRef;
    /**
     * Sets the buttons to use on the modal dialog.
     *
     * @param buttons - list of buttons to display
     */
    buttons(buttons: SohoModalButton[]): SohoMessageRef;
    /**
     * Is this an error dialog?
     *
     * @param isError - true if this dialog is to be styled an an alert.
     */
    isError(isError: boolean): SohoMessageRef;
    /**
     * Sets the 'message' that the message dialog displays.
     *
     * @param message - a selector or string representing the dialog content.
     */
    message(message: string): SohoMessageRef;
    /**
     * Sets the 'status' of the modal control.
     */
    status(status: string): SohoMessageRef;
    /**
     * Sets the 'cssClass' of the modal control.
     */
    cssClass(cssClass: string): SohoMessageRef;
    /**
     * If true, it will show a close icon button on the top right of the message.
     *
     * @param showCloseBtn - if true, the x button will be shown.
     */
    showCloseBtn(showCloseBtn: boolean): SohoMessageRef;
    /**
     * Sets the 'allowTags' of the modal control.
     */
    allowedTags(allowedTags: string): SohoMessageRef;
    /**
     * Sets the element to focus on when the modal is closed.
     *
     * @param returnFocus - a jQuery element or CSS selector string of the element to focus.
     */
    returnFocus(returnFocus: JQuery | string): SohoMessageRef;
    /**
     * If true, causes the modal's trigger element not to become focused once the modal is closed.
     *
     * @param noRefocus - if true, the trigger element will not be refocused.
     */
    noRefocus(noRefocus: boolean): SohoMessageRef;
    /**
     * Controls the opacity of the background overlay.
     *
     * @param overlayOpacity - The percent between 0 and 1 of opacity to use.
     */
    overlayOpacity(overlayOpacity: number): SohoMessageRef;
    /**
     * Causes this modal instance to become hidden when another modal is displayed over top.
     *
     * @param hideUnderneath - If it should be on top or bottom.
     */
    hideUnderneath(hideUnderneath: boolean): SohoMessageRef;
    /**
     * Causes this modal instance to become hidden when another modal is displayed over top.
     *
     * @param hideUnderneath - If it should be on top or bottom.
     */
    attributes(attributes: Array<Object> | Object): SohoMessageRef;
    /**
     * Dialog result property.
     *
     * @param dialogResult - the stored restult of the dialog.
     */
    set dialogResult(dialogResult: any);
    get dialogResult(): any;
    /**
     * Constructor.
     *
     * @param placeholder for the dialog; defaults to the body.
     */
    constructor();
    /**
     * Displays the message.
     *
     * @return the dialog ref.
     */
    open(): SohoMessageRef;
    /**
     * Closes the modal dialog, if open.
     *
     * @param dialogResult - optional result - held for the caller.
     */
    close(dialogResult?: any): SohoMessageRef;
    /**
     * Registers a before open guard.
     *
     * @param eventFn - the function to call before openning the dialog.
     */
    beforeOpen(eventFn: () => boolean): SohoMessageRef;
    /**
     * Opened Event.
     *
     * This event is fired when the dialog is being opened.
     *
     * @param eventFn - the function to invoke when the dialog is to be opened.
     */
    opened(eventFn: Function): SohoMessageRef;
    /**
     * Registers a before close guard.
     *
     * @param eventFn - the function to call before closing the dialog.
     */
    beforeClose(eventFn: () => boolean): SohoMessageRef;
    /**
     * Handles the 'beforeOpen' event, fired before the modal dialog
     * has been opened.
     *
     * @param event - full event object.
     *
     * @return true if the dialog can be opened; otherwise false if veoted.
     */
    private onBeforeOpen;
    /**
     * Handles the 'beforeCloseEvent, fired before the modal dialog
     * is closed, allowing the closure to be vetoed.
     *
     * @param event - event object.
     * @return true if the dialog can be closed; otherwise false if veoted.
     */
    private onBeforeClose;
    /**
     * Handles the 'open' event, fired just before
     * the focus is assigned to a message.
     *
     * @param event - full event object.
     */
    private onOpen;
}

/**
 * This service is used to create message dialogs.
 */
declare class SohoMessageService {
    /**
     * Constructor.
     */
    constructor();
    /**
     * Creates a dialog defined by the given message, returning a reference to the
     * associated dialog that can be interacted with.
     *
     * The dialog won't be open until open is called on the returned instance,
     * see the message ref api for further methods.
     *
     * @parent options - a compete set of options; can be null.
     *
     * @return the message reference.
     */
    message(options?: SohoMessageOptions): SohoMessageRef;
    /**
     * Creates an error message, defined by the given options.
     *
     * The dialog won't be open until open is called on the returned instance,
     * see the message ref api for further methods.
     *
     * @return the message reference.
     */
    error(options?: SohoMessageOptions): SohoMessageRef;
    /**
     * Creates an alert message, defined by the given options.
     *
     * The dialog won't be open until open is called on the returned instance,
     * see the message ref api for further methods.
     *
     * @return the message reference.
     */
    alert(options?: SohoMessageOptions): SohoMessageRef;
    /**
     * Creates an confirm (positive) message, defined by the given options.
     *
     * The dialog won't be open until open is called on the returned instance,
     * see the message ref api for further methods.
     *
     * @return the message reference.
     */
    confirm(options?: SohoMessageOptions): SohoMessageRef;
    /**
   * Creates an info message, defined by the given options.
   *
   * The dialog won't be open until open is called on the returned instance,
   * see the message ref api for further methods.
   *
   * @return the message reference.
   */
    info(options?: SohoMessageOptions): SohoMessageRef;
    /**
   * Creates an success message, defined by the given options.
   *
   * The dialog won't be open until open is called on the returned instance,
   * see the message ref api for further methods.
   *
   * @return the message reference.
   */
    success(options?: SohoMessageOptions): SohoMessageRef;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoMessageService>;
}

declare class SohoModalDialogModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModalDialogModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoModalDialogModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoModalDialogModule>;
}

/**
 * Wrapper for the jQuery modal control.
 *
 */
declare class SohoModalDialogRef<T> {
    private appRef;
    private injector;
    private ngZone;
    private service;
    /** Component - if the content is derived from an existing component. */
    private componentRef?;
    /** Vetoable Event Guard */
    private eventGuard;
    /**
     * Closes the modal dialogs if router navigation is detected, this prevents diaslogs from being
     * left open when navigating.
     */
    private _closeOnNavigation;
    /** Selector referencing the modal-dialog after it has been moved to the dialog container. */
    private jQueryElement?;
    /** Soho Control Api */
    private modal?;
    /** The result of the dialog. */
    private _dialogResult;
    /** Event fired when the modal is opened. */
    private open$;
    /** Event fired when the modal is closed. */
    private close$;
    /** Event fired after closing the modal. */
    private afterClose$;
    /** Event fired after openning the modal dialog. */
    private afterOpen$;
    /** Handle resource tidy up of this class. */
    private destroyed$;
    /**
     * The component displayed inside the modal frame, if specified.  This may
     * be null if the dialog is built from an HTML fragment or a jQuery selector.
     *
     * @returns the contained component dialog.
     */
    get componentDialog(): T | undefined;
    /**
     * The buttonset API for the modal dialog.
     *
     * @returns the buttonset API for the modal dialog, if initialised.
     */
    get buttonsetAPI(): SohoButtonsetStatic | undefined;
    /**
     * Cached options.
     */
    private _options;
    /**
     * Sets the whole options block for this modal dialog.
     *
     * @param options - the options to set.
     */
    options(options: SohoModalOptions): SohoModalDialogRef<T>;
    /**
     * Sets the frame height for the dialog.
     *
     * @param frameHeight - the extra frame height to allow.
     */
    frameHeight(frameHeight: number): SohoModalDialogRef<T>;
    /**
     * Sets the frame width for the dialog.
     *
     * @param frameWidth - the extra frame width to allow.
     */
    frameWidth(frameWidth: number): SohoModalDialogRef<T>;
    /**
     * A call back function that can be used to return data for the modal. This is the callback form of the before show event.
     *
     * @param beforeShow - The callback function
     */
    beforeShow(beforeShow: any): SohoModalDialogRef<T>;
    /**
     * If true, show a close icon button on the top right of the modal.
     *
     * @param showCloseBtn - if true the x will be shown.
     */
    showCloseBtn(showCloseBtn: boolean): SohoModalDialogRef<T>;
    /**
     * Optional max width to add in pixels.
     *
     * @param maxWidth - The width in pixels
     */
    maxWidth(maxWidth: number): SohoModalDialogRef<T>;
    /**
     * Optional width to set the text of the buttonset.
     *
     * @param buttonsetTextWidth - The width of buttonset text.
     */
    buttonsetTextWidth(buttonsetTextWidth: number | string): SohoModalDialogRef<T>;
    /**
     * If true, adds tabindex="0" to the modal body wrapper for keyboard navigation of scrollable content.
     *
     * @param contentFocusable - Whether the modal content should be focusable.
     */
    contentFocusable(contentFocusable: boolean): SohoModalDialogRef<T>;
    /**
     * Sets the title of the modal dialog.
     *
     * @param title - the title of the dialog.
     */
    title(title: string): SohoModalDialogRef<T>;
    /**
     * Sets the icon of the modal dialog title
     * @param icon - the icon name without icon-
     */
    icon(icon: string): SohoModalDialogRef<T>;
    /**
     * Sets the class to add for color and placement on the icon
     * @param icon - the css class name
     */
    iconClass(icon: string): SohoModalDialogRef<T>;
    /**
     * Sets the buttons to use on the modal dialog.
     *
     * @param buttons - list of buttons to display
     */
    buttons(buttons: SohoModalButton[]): SohoModalDialogRef<T>;
    /**
     * Sets the 'id' that the modal control uses.
     *
     * @param id - the id.
     */
    id(id: string): SohoModalDialogRef<T>;
    /**
     * Sets the 'trigger' that the modal control uses.
     *
     * @param trigger - when to open the dialog.
     */
    trigger(trigger: SohoModalTriggerType): SohoModalDialogRef<T>;
    /**
     * Sets the 'isAlert' that the modal control uses.
     *
     * @param isAlert - true if this dialog is to be styled an an alert.
     */
    isAlert(isAlert: boolean): SohoModalDialogRef<T>;
    /**
     * Sets the fullsize configuration that the modal control uses.
     *
     * @param fullsize - The full size configuration to use.
     */
    fullsize(fullsize: SohoModalFullSize): SohoModalDialogRef<T>;
    /**
     * Sets the breakpoint configuration that the modal control uses in full size mode(s).
     *
     * @param breakpoint - The full size configuration to use.
     */
    breakpoint(breakpoint: SohoModalBreakPoint): SohoModalDialogRef<T>;
    /**
     * Controls the opacity of the background overlay.
     *
     * @param overlayOpacity - The percent between 0 and 1 of opacity to use.
     */
    overlayOpacity(overlayOpacity: number): SohoModalDialogRef<T>;
    /**
     * Causes this modal instance to become hidden when another modal is displayed over top.
     *
     * @param hideUnderneath - If it should be on top or bottom.
     */
    hideUnderneath(hideUnderneath: boolean): SohoModalDialogRef<T>;
    /**
     * if true, causes the modal to not exit when the enter key is pressed.
     *
     * @param suppressEnterKey - If it supress enter
     */
    suppressEnterKey(suppressEnterKey: boolean): SohoModalDialogRef<T>;
    /**
     * If true, causes the modal's trigger element not to become focused once the modal is closed.
     *
     * @param noRefocus - If true, refocus
     */
    noRefocus(noRefocus: boolean): SohoModalDialogRef<T>;
    /**
     * The modal's trigger element to keep refocused once the modal is closed. This can be html or jquery object or query selector as string.
     *
     * @param triggerButton - The element (for example a button) to refocus on close.
     */
    triggerButton(triggerButton: boolean): SohoModalDialogRef<T>;
    /**
     * Add extra attributes like id's to the component
     */
    attributes(attributes: boolean): SohoModalDialogRef<T>;
    /**
     * Sets the 'content' that the modal control uses.
     *
     * @param content - a selector or string representing the dialog content.
     */
    content(content: JQuery | string): SohoModalDialogRef<T>;
    /**
     * Sets the 'cssClass' of the modal control.
     */
    cssClass(cssClass: string): SohoModalDialogRef<T>;
    /**
     * Sets the 'autoFocus' of the modal control.
     *
     * @param autoFocus -if true; the dialog will autoFocus.
     */
    autoFocus(autoFocus: boolean): SohoModalDialogRef<T>;
    /**
     * Sets the 'noPadding' to remove paddings from the modal body wrapper.
     * @param noPadding - if true; the content will have no paddings.
     */
    noPadding(noPadding: boolean): SohoModalDialogRef<T>;
    /**
     * Sets the 'initialFocus' CSS selector for the element to focus on when the modal is opened.
     *
     * @param initialFocus - a CSS selector string targeting the element to focus.
     */
    initialFocus(initialFocus: string): SohoModalDialogRef<T>;
    /**
     * Applies a function to the instantiated component,
     * allowing the component to be modified, or initialised.
     *
     * The function is provided with a typed value for the
     * instance.
     *
     * @param component - the instantated instance.
     * @return the dialog ref for onward assignment.
     */
    apply(fn: (component: T) => void): SohoModalDialogRef<T>;
    /**
     * When set to true, this dialog is closed when navigation is detected.
     *
     * @param closeOnNavigation controls the close behaviour when navigating.
     * @return the dialog ref for support a fluent api.
     */
    closeOnNavigation(closeOnNavigation: boolean): SohoModalDialogRef<T>;
    /**
     * Dialog result property.
     *
     * @param dialogResult - the stored restult of the dialog.
     */
    set dialogResult(dialogResult: any);
    get dialogResult(): any;
    /**
     * Constructor.
     *
     * @paran appRef - application reference used to insert the component.
     */
    constructor(router: Router, appRef: ApplicationRef, componentFactoryResolver: ComponentFactoryResolver, injector: Injector, ngZone: NgZone, service: SohoModalDialogService, settings: SohoModalOptions, modalComponent?: ComponentType<T>);
    /**
     * Opens the dialog.
     *
     * @return the dialog ref.
     */
    open(): SohoModalDialogRef<T>;
    /**
     * Closes the modal dialog, if open.  The dialog is not closed
     * fully until the 'afterClosed' event is fired.
     *
     * @param dialogResult - optional result - passed back to the caller.
     */
    close(dialogResult?: any): SohoModalDialogRef<T>;
    /**
     * Destroys the modal dialog.
     */
    destroy(): SohoModalDialogRef<T>;
    /**
     * Registers a before open guard.
     *
     * SOHO-4892 - Returning false from beforeOpen or beforeDestroy breaks dialogs
     *
     * @param eventFn - the function to call before openning the dialog.
     */
    beforeOpen(eventFn: (dialogRef?: SohoModalDialogRef<T>) => boolean): SohoModalDialogRef<T>;
    /**
     * Opened Event.
     *
     * This event is fired when the dialog is being opened.
     *
     * @param eventFn - the function to invoke when the dialog is to be opened.
     */
    opened(eventFn: Function): SohoModalDialogRef<T>;
    /**
     * Opened Event.
     *
     * This event is fired after the dialog has been opened.
     *
     * @param eventFn - the function to invoke when the dialog is to be opened.
     */
    afterOpen(eventFn: Function): SohoModalDialogRef<T>;
    /**
     * Registers a before close guard.
     *
     * @param eventFn - the function to call before closing the dialog.
     * @param isAsync - if callback is asynchronous or not
     */
    beforeClose(eventFn: SohoModalDialogEventVetoFunction<T>): SohoModalDialogRef<T>;
    /**
     * Closed Event.
     *
     * This event is fired when the dialog is being closed.
     *
     * @param eventFn - the function to invoke when the dialog is to be closed.
     */
    closed(eventFn: SohoModalDialogEventFunction<T>): SohoModalDialogRef<T>;
    /**
     * After Closed Event.
     *
     * This event is fired, with the result of the dialog, when the dialog has been
     * closed and destroyed.
     *
     * @param eventFn - the function to invoke after the dialog has been closed.
     */
    afterClose(eventFn: SohoModalDialogEventFunction<T>): SohoModalDialogRef<T>;
    /**
     * Registers a before destroy guard.
     *
     * SOHO-4892 - Returning false from beforeOpen or beforeDestroy breaks dialogs
     *
     * @param eventFn - the function to call before destroying the dialog.
     */
    beforeDestroy(eventFn: () => boolean): SohoModalDialogRef<T>;
    /**
     * Handles the 'afterOpen' event, fired after the modal dialog
     * has been opened.
     *
     * @param event - full event object.
     */
    private onAfterOpen;
    /**
     * Handles the 'beforeOpen' event, fired before the modal dialog
     * has been opened.
     *
     * @param event - full event object.
     *
     * @return true if the dialog can be opened; otherwise false if veoted.
     */
    private onBeforeOpen;
    /**
     * Handles the 'beforeClose' event, fired before the modal dialog
     * has been destroyed.
     *
     * @param event - event object.
     * @return true if the dialog can be closed; otherwise false if veoted.
     */
    private onBeforeClose;
    /**
     * Handles the 'beforeDestroy' event, fired before the modal dialog
     * has been destroyed.
     *
     * @param event - event object.
     * @return true if the dialog can be destroyed; otherwise false if veoted.
     */
    private onBeforeDestroy;
    /**
     * Handles the 'open' event, fired just before
     * the focus is assigned to a modal.
     *
     * @param event - full event object.
     */
    private onOpen;
    /**
     * Handles the close event.
     *
     * @param event - full event object.
     * @param isCancelled - is true if the cancel button was pressed; otherwise false.
     */
    private onClose;
    /**
     * Handles the 'afterClose' event, fired when the dialog
     * has been closed and tidy up is required.
     *
     * @param event - full event object.
     */
    private onAfterClose;
}
/**
 * Close/AfterClose event handler.
 *
 * @param result - the dialog result (if set); may be undefined.
 * @param dialogRef - the dialog reference (or wrapper); never null.
 * @param dialogComponent - the component hosted in the modal; may be undefined.
 */
type SohoModalDialogEventFunction<T> = (result: any, dialogRef: SohoModalDialogRef<T>, dialogComponent: T) => void;
/**
 * BeforeClose event handler.
 *
 * @param dialogRef - the dialog reference; never null.
 */
type SohoModalDialogEventVetoFunction<T> = (dialogRef: SohoModalDialogRef<T>) => boolean | Promise<boolean>;
/**
 * Contract for all SohoModalDialogComponents.
 */
interface SohoModalComponent<T> {
}
/**
 * Vetoable Event Handlers.
 */
interface SohoModalDialogVetoableEventGuard<T> {
    /**
     *  Track if cancelled
     */
    isCancelled?: boolean;
    /**
     * Invoked before a modal is opened.
     *
     * @return false to veto the open action; otherwise true.
     */
    beforeOpen?(dialogRef: SohoModalDialogRef<T>): boolean;
    /**
     * Invoked before a modal is closed, allowing the close to be vetoed.
     *
     * @param result - the value of the dialog result, passed to close or set.
     * @param dialogRef - a reference to the modal dialog wrapper.
     * @param dialogComponent - the underlying dialog component displayed in the dialog.
     * @return false to veto the close action; otherwise true.
     */
    beforeClose?(result: any, dialogRef: SohoModalDialogRef<T>, dialogComponent: T): boolean;
    /**
     * Invoked before a modal is opened.
     *
     * @return false to veto the destroy action; otherwise true.
     */
    beforeDestroy?(): boolean;
}

/**
 * This service is used to create a modal dialog, based on the content
 * of an Angular Componnent on the screen.
 */
declare class SohoModalDialogService {
    private readonly appRef;
    private readonly componentFactoryResolver;
    private readonly injector;
    private readonly ngZone;
    private readonly router;
    /** Tracks whether any modal is currently open to prevent duplicate instances from rapid triggers. */
    _hasOpenModal: boolean;
    /**
     * Constructor.
     *
     * @param appRef - application reference; must not be null.
     * @param componentFactoryResolver - used to create component factories for components dynamically.
     * @param injector - the current in scope injector, use as a delegate.
     * @param ngZone - the angular zone; must not be null.
     * @router
     */
    constructor(appRef: ApplicationRef, componentFactoryResolver: ComponentFactoryResolver, injector: Injector, ngZone: NgZone, router: Router);
    /**
     * Creates a modal dialog defined by the given component, returning a reference to the
     * dialog that can be interacted with.
     *
     * The component has the potential to include the dialog reference when it is
     * instantiated, as a provider.
     *
     * The dialog won't necessarily be open yet, see the dialog ref api for further methods.
     *
     * @param component - The type of the component to instantiate; must not be null.
     * @param parent - The parent container; obsolete but parameter kept for backwards API compatibility. Has no effect.
     * @param options - The control options to use.
     *
     * @return the modal dialog reference.
     */
    modal<T>(component: ComponentType<T>, _parent?: ViewContainerRef, options?: SohoModalOptions): SohoModalDialogRef<T>;
    /**
     * Creates a modal dialog (using the content defined in the options), returning a reference to the
     * dialog that can be interacted with.
     *
     * The dialog won't be open.
     *
     * @return the modal dialog reference.
     */
    message<T>(content: string | JQuery): SohoModalDialogRef<T>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModalDialogService, [null, null, null, null, { optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoModalDialogService>;
}
/**
 * Object with a "new"" method returning the type T.
 */
type ComponentType<T> = new (...args: any[]) => T;

/**
 * Angular Wrapper for the Soho Module Nav control.
 * This Component attaches to an element annotated with the `soho-module-nav` attribute,
 */
declare class SohoModuleNavComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    /** Reference to the jQuery element. */
    private jQueryElement?;
    /** Reference to the annotated SoHoXi control */
    private modulenav?;
    /** Stored settings */
    private _options;
    /** Internal use flags */
    private _updateRequired;
    /** Constructor. */
    constructor(elementRef: ElementRef, ngZone: NgZone);
    set accordionSettings(val: SohoAccordionOptions | undefined);
    get accordionSettings(): SohoAccordionOptions | undefined;
    set displayMode(val: SohoModuleNavDisplayMode | undefined);
    get displayMode(): SohoModuleNavDisplayMode | undefined;
    set mobileBehavior(val: boolean);
    get mobileBehavior(): boolean;
    set breakpoint(val: SohoModuleNavBreakPoint);
    get breakpoint(): SohoModuleNavBreakPoint;
    set showOverlay(val: boolean);
    get showOverlay(): boolean;
    set showModuleSwitcher(val: boolean);
    get showModuleSwitcher(): boolean;
    set showGuestSection(val: boolean);
    get showGuestSection(): boolean;
    set showSearchBar(val: boolean);
    get showSearchBar(): boolean;
    set enableOutsideClick(val: boolean);
    get enableOutsideClick(): boolean;
    set filterable(val: boolean);
    get filterable(): boolean;
    set initChildren(val: boolean);
    get initChildren(): boolean;
    set pinSections(val: boolean);
    get pinSections(): boolean;
    set showDetailView(val: boolean);
    get showDetailView(): boolean;
    displaymodechange: EventEmitter<SohoModuleNavDisplayModeChangeEvent>;
    accordionAPI(): SohoAccordionStatic | undefined;
    containerEl(): HTMLElement | undefined;
    switcherAPI(): SohoModuleNavSwitcherStatic | undefined;
    searchAPI(): SohoSearchFieldStatic | undefined;
    settingsAPI(): SohoModuleNavSettingsStatic | undefined;
    init(): void;
    /** Triggers a UI Resync. */
    updated(val?: SohoModuleNavOptions): void;
    teardown(): void;
    /**
     * Updates the accordion and expands the target header
     * @param sohoModuleNavComponent
     * @param target
     */
    updateLazy(sohoModuleNavComponent: SohoModuleNavComponent, target: any): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoModuleNavComponent, "soho-module-nav, [soho-module-nav]", never, { "accordionSettings": { "alias": "accordionSettings"; "required": false; }; "displayMode": { "alias": "displayMode"; "required": false; }; "mobileBehavior": { "alias": "mobileBehavior"; "required": false; }; "breakpoint": { "alias": "breakpoint"; "required": false; }; "showOverlay": { "alias": "showOverlay"; "required": false; }; "showModuleSwitcher": { "alias": "showModuleSwitcher"; "required": false; }; "showGuestSection": { "alias": "showGuestSection"; "required": false; }; "showSearchBar": { "alias": "showSearchBar"; "required": false; }; "enableOutsideClick": { "alias": "enableOutsideClick"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "initChildren": { "alias": "initChildren"; "required": false; }; "pinSections": { "alias": "pinSections"; "required": false; }; "showDetailView": { "alias": "showDetailView"; "required": false; }; }, { "displaymodechange": "displaymodechange"; }, never, ["*"], true, never>;
}

declare class SohoModuleNavModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoModuleNavModule, never, [typeof SohoModuleNavComponent], [typeof SohoModuleNavComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoModuleNavModule>;
}

/**
 * Angular Wrapper for the Soho Module Nav Container element.
 * This Component attaches to an element annotated with the `soho-module-nav-container` attribute,
 */
declare class SohoModuleNavContainerComponent {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoModuleNavContainerComponent, "soho-module-nav-container, [soho-module-nav-container]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoModuleNavContainerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavContainerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoModuleNavContainerModule, never, [typeof SohoModuleNavContainerComponent], [typeof SohoModuleNavContainerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoModuleNavContainerModule>;
}

/**
 * Angular Wrapper for the Soho Module Nav Settings element.
 * This Component attaches to an element annotated with the `soho-module-nav-settings` attribute,
 */
declare class SohoModuleNavSettingsComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    /** Reference to the jQuery element. */
    private jQueryElement?;
    /** Reference to the annotated SoHoXi control */
    private modulenavsettings?;
    /** Stored settings */
    private _options;
    /** Internal use flags */
    private _updateRequired;
    /** Constructor. */
    constructor(elementRef: ElementRef, ngZone: NgZone);
    accordionAPI(): SohoAccordionStatic | undefined;
    accordionEl(): HTMLElement | undefined;
    menuAPI(): SohoPopupMenuStatic | undefined;
    init(): void;
    /** Triggers a UI Resync. */
    updated(val?: SohoModuleNavSettingsOptions): void;
    teardown(): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavSettingsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoModuleNavSettingsComponent, "soho-module-nav-settings, [soho-module-nav-settings]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoModuleNavSettingsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavSettingsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoModuleNavSettingsModule, never, [typeof SohoModuleNavSettingsComponent], [typeof SohoModuleNavSettingsComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoModuleNavSettingsModule>;
}

/**
 * Angular Wrapper for the Soho Module Nav Switcher element.
 * This Component attaches to an element annotated with the `soho-module-nav-switcher` attribute,
 */
declare class SohoModuleNavSwitcherComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    /** Reference to the jQuery element. */
    private jQueryElement?;
    /** Reference to the annotated SoHoXi control */
    private modulenavswitcher?;
    /** Stored settings */
    private _options;
    /** Internal use flags */
    private _updateRequired;
    /** Constructor. */
    constructor(elementRef: ElementRef, ngZone: NgZone);
    set displayMode(val: SohoModuleNavDisplayMode | undefined);
    get displayMode(): SohoModuleNavDisplayMode | undefined;
    set generate(val: boolean | undefined);
    get generate(): boolean | undefined;
    set changeIconOnSelect(val: boolean | undefined);
    get changeIconOnSelect(): boolean | undefined;
    set icon(val: SohoModuleNavSwitcherIconSetting);
    get icon(): SohoModuleNavSwitcherIconSetting;
    set noSearch(val: boolean | undefined);
    get noSearch(): boolean | undefined;
    set moduleButtonText(val: string | undefined);
    get moduleButtonText(): string | undefined;
    set roleDropdownLabel(val: string | undefined);
    get roleDropdownLabel(): string | undefined;
    set roles(val: Array<SohoModuleNavSwitcherRoleRecord> | undefined);
    get roles(): Array<SohoModuleNavSwitcherRoleRecord> | undefined;
    set disabled(val: boolean | undefined);
    get disabled(): boolean | undefined;
    rolechange: EventEmitter<JQuery.TriggeredEvent<any, any, any, any>>;
    listcontextmenu: EventEmitter<JQuery.TriggeredEvent<any, any, any, any>>;
    modulebuttonclick: EventEmitter<JQuery.TriggeredEvent<any, any, any, any>>;
    accordionAPI(): SohoAccordionStatic | undefined;
    accordionEl(): HTMLElement | undefined;
    moduleButtonAPI(): SohoButtonStatic | undefined;
    roleDropdownAPI(): SohoDropDownStatic | undefined;
    init(): void;
    toggleModuleButtonFocus(doFocus?: boolean): void;
    /** Triggers a UI Resync. */
    updated(val?: SohoModuleNavSwitcherOptions): void;
    teardown(): void;
    /** Sets the roles array programmatically */
    setRoles(val: Array<SohoModuleNavSwitcherRoleRecord>): void;
    /** Sets the current dropdown role using <option> tag's `value` */
    selectRole(val: string): void;
    /** Triggered by a Module Button click */
    onModuleButtonClick(event: JQuery.TriggeredEvent): void;
    /** Triggered by a dropdown change */
    onRoleChange(event: JQuery.TriggeredEvent): void;
    /** Triggered by a right click on the dropdown */
    onListContextMenu(event: JQuery.TriggeredEvent): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavSwitcherComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoModuleNavSwitcherComponent, "soho-module-nav-switcher, [soho-module-nav-switcher]", never, { "displayMode": { "alias": "displayMode"; "required": false; }; "generate": { "alias": "generate"; "required": false; }; "changeIconOnSelect": { "alias": "changeIconOnSelect"; "required": false; }; "icon": { "alias": "icon"; "required": false; }; "noSearch": { "alias": "noSearch"; "required": false; }; "moduleButtonText": { "alias": "moduleButtonText"; "required": false; }; "roleDropdownLabel": { "alias": "roleDropdownLabel"; "required": false; }; "roles": { "alias": "roles"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "rolechange": "rolechange"; "listcontextmenu": "listcontextmenu"; "modulebuttonclick": "modulebuttonclick"; }, never, never, true, never>;
}

declare class SohoModuleNavSwitcherModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoModuleNavSwitcherModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoModuleNavSwitcherModule, never, [typeof SohoIconModule, typeof SohoModuleNavSwitcherComponent], [typeof SohoModuleNavSwitcherComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoModuleNavSwitcherModule>;
}

declare class SohoMonthViewComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    ref: ChangeDetectorRef;
    isMonthView: boolean;
    dataInit: boolean;
    set monthviewOptions(monthviewOptions: SohoMonthViewOptions | undefined);
    get monthviewOptions(): SohoMonthViewOptions | undefined;
    /**
     * The name of the locale to use for this instance. If not set the current locale will be used.
     */
    set locale(locale: string);
    get locale(): string;
    /**
     * Initial month to show.
     */
    set month(month: number | undefined);
    get month(): number | undefined;
    /**
     * Initial year to show.
     */
    set year(year: number | undefined);
    get year(): number | undefined;
    /**
     * The initial selected day to show.
     */
    set day(day: number | undefined);
    get day(): number | undefined;
    /**
     * The date to highlight as selected/today.
     */
    set activeDate(activeDate: number | undefined);
    get activeDate(): number | undefined;
    /**
     * The date to highlight as selected/today (as an array for islamic)
     */
    set activeDateIslamic(activeDateIslamic: number | undefined);
    get activeDateIslamic(): number | undefined;
    /**
     * Is it in a popup (datepicker using it)
     */
    set isPopup(isPopup: boolean | undefined);
    get isPopup(): boolean | undefined;
    /**
     * If true, will set it as inPage month view.
     */
    set inPage(inPage: boolean | undefined);
    get inPage(): boolean | undefined;
    /**
     * If true, will set the month-year title as button for inPage.
     */
    set inPageTitleAsButton(inPageTitleAsButton: boolean | undefined);
    get inPageTitleAsButton(): boolean | undefined;
    /**
     * If true, will set to be toggleable.
     */
    set inPageToggleable(inPageToggleable: boolean | undefined);
    get inPageToggleable(): boolean | undefined;
    /**
     * If true, will init as expanded
     */
    set inPageExpanded(inPageExpanded: boolean | undefined);
    get inPageExpanded(): boolean | undefined;
    /**
     * Set first day of the week. '1' would be Monday.
     */
    set firstDayOfWeek(firstDayOfWeek: number | undefined);
    get firstDayOfWeek(): number | undefined;
    /**
     * If true the today button is shown on the header.
     */
    set showToday(showToday: boolean | undefined);
    get showToday(): boolean | undefined;
    /**
     * Indicates this is a month picker on the month and week view.
     * Has some slight different behavior.
     */
    set isMonthPicker(isMonthPicker: boolean | undefined);
    get isMonthPicker(): boolean | undefined;
    /**
     * If false the year and month switcher will be disabled.
     */
    set showMonthYearPicker(showMonthYearPicker: boolean | undefined);
    get showMonthYearPicker(): boolean | undefined;
    /**
     * Shows the legend below the table.
     */
    set showLegend(showLegend: boolean | undefined);
    get showLegend(): boolean | undefined;
    /**
     * Legend Build up.
     */
    set legend(legend: SohoMonthViewLegend[] | undefined);
    get legend(): SohoMonthViewLegend[] | undefined;
    /**
     * If true the days portion of the calendar will be hidden.
     * Usefull for Month/Year only formats.
     */
    set hideDays(hideDays: boolean | undefined);
    get hideDays(): boolean | undefined;
    /**
     * Disable dates in various ways.
     * For example `{minDate: 'M/d/yyyy', maxDate: 'M/d/yyyy'}`.
     * Dates should be in format M/d/yyyy
     */
    set disable(disable: SohoDatePickerDisable | undefined);
    get disable(): SohoDatePickerDisable | undefined;
    /**
     * The number of years ahead to show in the month/year picker should total 9 with yearsBack.
     */
    set yearsBack(yearsBack: number | undefined);
    get yearsBack(): number | undefined;
    /**
     * The number of years back to show in the month/year picker should total 9 with yearsAhead.
     */
    set yearsAhead(yearsAhead: number | undefined);
    get yearsAhead(): number | undefined;
    /**
     * Range between two dates with various options.
     */
    set range(range: SohoMonthViewRange[] | undefined);
    get range(): SohoMonthViewRange[] | undefined;
    /**
     * If true the month days can be clicked to select
     */
    set selectable(selectable: boolean | undefined);
    get selectable(): boolean | undefined;
    /**
     * Callback that fires when a month day is clicked.
     */
    set onSelected(onSelected: boolean | undefined);
    get onSelected(): boolean | undefined;
    /**
     * Callback that fires when a key is pressed down.
     */
    set onKeyDown(onKeyDown: boolean | undefined);
    get onKeyDown(): boolean | undefined;
    /**
     * If true the Next Previous buttons will shown on the header.
     */
    set showNextPrevious(showNextPrevious: boolean | undefined);
    get showNextPrevious(): boolean | undefined;
    /**
     * Call back for when the view changer is changed.
     */
    set changeViewCallback(changeViewCallback: Function | undefined);
    get changeViewCallback(): Function | undefined;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    monthRendered: EventEmitter<SohoMonthViewRenderEvent>;
    selected: EventEmitter<SohoMonthViewSelectedEvent>;
    /**
     * Local variables
     */
    private jQueryElement?;
    private monthview?;
    private _monthviewOptions?;
    private updateRequired?;
    private updateLegend?;
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    onMonthViewRenderedEvent(event: SohoMonthViewRenderEvent): void;
    onMonthViewSelectedEvent(event: SohoMonthViewSelectedEvent): void;
    /**
     * Handle updated settings and values.
     */
    updated(settings?: SohoMonthViewOptions): void;
    /**
     * Mark the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    /**
     * Tear down the markup for the monthview
     */
    teardown(): void;
    /**
     * Destroy the markup and any other resources.
     */
    destroy(): void;
    /**
     * Shows the given month and year.
     */
    showMonth(month: number, year: number): void;
    /**
     * Cleanup just before Angular destroys the component.
     * Unsubscribe observables, detach event handlers and remove other resources to avoid memory leaks.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMonthViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoMonthViewComponent, "[soho-monthview]", never, { "monthviewOptions": { "alias": "monthviewOptions"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "month": { "alias": "month"; "required": false; }; "year": { "alias": "year"; "required": false; }; "day": { "alias": "day"; "required": false; }; "activeDate": { "alias": "activeDate"; "required": false; }; "activeDateIslamic": { "alias": "activeDateIslamic"; "required": false; }; "isPopup": { "alias": "isPopup"; "required": false; }; "inPage": { "alias": "inPage"; "required": false; }; "inPageTitleAsButton": { "alias": "inPageTitleAsButton"; "required": false; }; "inPageToggleable": { "alias": "inPageToggleable"; "required": false; }; "inPageExpanded": { "alias": "inPageExpanded"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "showToday": { "alias": "showToday"; "required": false; }; "isMonthPicker": { "alias": "isMonthPicker"; "required": false; }; "showMonthYearPicker": { "alias": "showMonthYearPicker"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "hideDays": { "alias": "hideDays"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; "yearsBack": { "alias": "yearsBack"; "required": false; }; "yearsAhead": { "alias": "yearsAhead"; "required": false; }; "range": { "alias": "range"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "onSelected": { "alias": "onSelected"; "required": false; }; "onKeyDown": { "alias": "onKeyDown"; "required": false; }; "showNextPrevious": { "alias": "showNextPrevious"; "required": false; }; "changeViewCallback": { "alias": "changeViewCallback"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "monthRendered": "monthRendered"; "selected": "selected"; }, never, ["*"], true, never>;
}

declare class SohoMonthViewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoMonthViewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoMonthViewModule, never, [typeof SohoMonthViewComponent], [typeof SohoMonthViewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoMonthViewModule>;
}

declare class SohoNotificationModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoNotificationModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoNotificationModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoNotificationModule>;
}

declare class SohoNotificationService {
    static ERROR: SohoNotificationType;
    static ALERT: SohoNotificationType;
    static INFO: SohoNotificationType;
    static SUCCESS: SohoNotificationType;
    /**
     * Show a notification using the specified options.
     */
    show(options: SohoNotificationOptions): void;
    /**
     * Hide a specified notification
     *
     * @param id id of notification
     */
    close(id: string): void;
    /**
     * Hide the latest notification in the list
     */
    closeLatest(): void;
    /**
     * Hide all the notifications in the list
     */
    closeAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoNotificationService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoNotificationService>;
}

declare class SohoNotificationBadgeComponent implements OnInit {
    private element;
    private ngZone;
    private jQueryElement;
    private notificationBadge?;
    private options?;
    constructor(element: ElementRef, ngZone: NgZone);
    set position(position: string | undefined);
    get position(): string | undefined;
    set color(color: string | undefined);
    get color(): string | undefined;
    set label(label: string | undefined);
    get label(): string | undefined;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    set visible(visible: boolean | undefined);
    get visible(): boolean | undefined;
    show(): void;
    hide(): void;
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoNotificationBadgeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoNotificationBadgeComponent, "[soho-notification-badge]", never, { "position": { "alias": "position"; "required": false; }; "color": { "alias": "color"; "required": false; }; "label": { "alias": "label"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "visible": { "alias": "visible"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoNotificationBadgeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoNotificationBadgeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoNotificationBadgeModule, never, [typeof SohoNotificationBadgeComponent], [typeof SohoNotificationBadgeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoNotificationBadgeModule>;
}

declare class SohoStandalonePagerComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private elementRef;
    private ngZone;
    set activePage(page: number);
    set dataset(dataset: any[]);
    set pageSize(pageSize: number);
    set pageSizes(pageSizes: number[]);
    set showFirstButton(showFirstButton: boolean);
    set showLastButton(showLastButton: boolean);
    set showNextButton(showNextButton: boolean);
    set showPreviousButton(showPreviousButton: boolean);
    set showPageSizeSelector(showPageSizeSelector: boolean);
    set showPageSelectorInput(showPageSelectorInput: boolean);
    set enableFirstButton(enableFirstButton: boolean);
    set enableLastButton(enableLastButton: boolean);
    set enablePreviousButton(enablePreviousButton: boolean);
    set enableNextButton(enableNextButton: boolean);
    set previousPageTooltip(previousPageTooltip: string);
    set firstPageTooltip(firstPageTooltip: string);
    set nextPageTooltip(nextPageTooltip: string);
    set lastPageTooltip(lastPageTooltip: string);
    set attachPageSizeMenuToBody(attachPageSizeMenuToBody: boolean);
    set smallPageSizeSelector(smallPageSizeSelector: boolean);
    set pageSizeMenuSettings(options: object);
    set attributes(attributes: object);
    firstPage: EventEmitter<Object>;
    lastPage: EventEmitter<Object>;
    previousPage: EventEmitter<Object>;
    nextPage: EventEmitter<Object>;
    pageSizeChange: EventEmitter<Object>;
    page: EventEmitter<Object>;
    private jQueryElement?;
    private pager?;
    private options;
    private updateRequired;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStandalonePagerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStandalonePagerComponent, "div[soho-standalone-pager]", never, { "activePage": { "alias": "activePage"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "pageSizes": { "alias": "pageSizes"; "required": false; }; "showFirstButton": { "alias": "showFirstButton"; "required": false; }; "showLastButton": { "alias": "showLastButton"; "required": false; }; "showNextButton": { "alias": "showNextButton"; "required": false; }; "showPreviousButton": { "alias": "showPreviousButton"; "required": false; }; "showPageSizeSelector": { "alias": "showPageSizeSelector"; "required": false; }; "showPageSelectorInput": { "alias": "showPageSelectorInput"; "required": false; }; "enableFirstButton": { "alias": "enableFirstButton"; "required": false; }; "enableLastButton": { "alias": "enableLastButton"; "required": false; }; "enablePreviousButton": { "alias": "enablePreviousButton"; "required": false; }; "enableNextButton": { "alias": "enableNextButton"; "required": false; }; "previousPageTooltip": { "alias": "previousPageTooltip"; "required": false; }; "firstPageTooltip": { "alias": "firstPageTooltip"; "required": false; }; "nextPageTooltip": { "alias": "nextPageTooltip"; "required": false; }; "lastPageTooltip": { "alias": "lastPageTooltip"; "required": false; }; "attachPageSizeMenuToBody": { "alias": "attachPageSizeMenuToBody"; "required": false; }; "smallPageSizeSelector": { "alias": "smallPageSizeSelector"; "required": false; }; "pageSizeMenuSettings": { "alias": "pageSizeMenuSettings"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "firstPage": "firstPage"; "lastPage": "lastPage"; "previousPage": "previousPage"; "nextPage": "nextPage"; "pageSizeChange": "pageSizeChange"; "page": "page"; }, never, never, true, never>;
}

declare class SohoPagerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPagerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoPagerModule, never, [typeof SohoIconModule, typeof SohoStandalonePagerComponent], [typeof SohoStandalonePagerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoPagerModule>;
}

/**
 * Angular Wrapper for the enterprise personalise widget.
 *
 * This component searches for an element with the attribute
 * 'soho-personalize'.
 */
declare class SohoPersonalizeDirective implements AfterViewInit, OnDestroy {
    private ngZone;
    /** Options. */
    options: SohoPersonalizeOptions;
    /** The starting color. */
    set colors(colors: string | SohoPersonalizeColors);
    /** The starting theme. */
    set theme(theme: string);
    changetheme: EventEmitter<SohoChangeThemePersonalizeEvent>;
    changecolors: EventEmitter<SohoChangeColorsPersonalizeEvent>;
    /** EP api */
    private personalize?;
    /** jQuery Widget */
    private jQueryElement?;
    /**
     * Constructor.
     */
    constructor(ngZone: NgZone);
    /**
     * After the control has been initialised, and the view is ready,
     * get the SoHoXi controls to apply any renderings.
     */
    ngAfterViewInit(): void;
    /**
     * The theme currently set
     */
    get currentTheme(): SohoTheme;
    /**
     * Return a list of all the available themes.
     *
     * @returns The list of themes.
     */
    themes(): SohoTheme[];
    /**
     * Return the colors used in the current theme that are recommended for personalization.
     *
     * @returns An object full of the colors with id, name, and hex value.
     */
    personalizationColors(): SohoPersonalizationColors;
    onChangeTheme(e: JQuery.TriggeredEvent, theme: string): void;
    onChangeColors(e: JQuery.TriggeredEvent, colors: any): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPersonalizeDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoPersonalizeDirective, "[soho-personalize]", never, { "options": { "alias": "options"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; }, { "changetheme": "changetheme"; "changecolors": "changecolors"; }, never, never, true, never>;
}

declare class SohoPersonalizeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPersonalizeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoPersonalizeModule, never, [typeof SohoPersonalizeDirective], [typeof SohoPersonalizeDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoPersonalizeModule>;
}

declare class SohoPieComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isPie(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any>);
    /** If true it renders as a donut chart. */
    set isDonut(value: boolean);
    /** Controls the animation speed. */
    set animationSpeed(value: number);
    /** true|false - will do or not do the animation and 'initial' will do only first time the animation. */
    set animate(value: any);
    /** If true, the component will not resize when resizing the page. There is tooltip values provided.
     * It will not be shown. If you still want lines at the lower breakpoint you can set this to true */
    set redrawOnResize(value: boolean);
    /** If false the center label will not be shown. */
    set hideCenterLabel(value: boolean);
    /** If false connector lines wont be shown. */
    set showLines(value: boolean);
    /** This defaults to false, when false and under 450px the lines. */
    set showLinesMobile(value: boolean);
    /** A setting that controls the line values and format. */
    set lines(value: SohoPieLinesOptions);
    /** If false the legend will not be shown. */
    set showLegend(value: boolean);
    /** Where to locate the legend. This can be bottom or right at the moment. */
    set legendPlacement(value: string);
    /** Where to locate the legend. This can be bottom or right at the moment. */
    set forceLegendPopup(value: boolean);
    /** A setting that controls the legend values and format. */
    set legend(value: SohoPieLegendOptions);
    /** If false now tooltips will be shown */
    set showTooltips(value: boolean);
    /** A setting that controls the tooltip values and format. */
    set tooltip(value: SohoPieTooltipOptions);
    /** If true center tooltip will be shown */
    set showCenterTooltip(value: boolean);
    /** If true chart height will fit in parent available height. */
    set fitHeight(value: boolean);
    /** An empty message will be displayed when there is no chart data. */
    set emptyMessage(value: SohoEmptyMessageOptions);
    /** Events */
    selected: EventEmitter<SohoPieSelectEvent>;
    unselected: EventEmitter<SohoPieSelectEvent>;
    rendered: EventEmitter<Object>;
    dblclick: EventEmitter<Object>;
    /**
     * @todo remove override of native element
     */
    contextmenu?: EventEmitter<Object[]>;
    private jQueryElement?;
    private pie?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    updated(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    setSelected(selected: SohoPieSelected): void;
    toggleSelected(selected: SohoPieSelected): void;
    getSelected(): Object | Object[] | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPieComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPieComponent, "[soho-pie]", never, { "dataset": { "alias": "dataset"; "required": false; }; "isDonut": { "alias": "isDonut"; "required": false; }; "animationSpeed": { "alias": "animationSpeed"; "required": false; }; "animate": { "alias": "animate"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "hideCenterLabel": { "alias": "hideCenterLabel"; "required": false; }; "showLines": { "alias": "showLines"; "required": false; }; "showLinesMobile": { "alias": "showLinesMobile"; "required": false; }; "lines": { "alias": "lines"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "legendPlacement": { "alias": "legendPlacement"; "required": false; }; "forceLegendPopup": { "alias": "forceLegendPopup"; "required": false; }; "legend": { "alias": "legend"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "showCenterTooltip": { "alias": "showCenterTooltip"; "required": false; }; "fitHeight": { "alias": "fitHeight"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; }, { "selected": "selected"; "unselected": "unselected"; "rendered": "rendered"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoPieModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPieModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoPieModule, never, [typeof SohoPieComponent], [typeof SohoPieComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoPieModule>;
}

declare class SohoPopDownDirective implements AfterViewInit, OnDestroy {
    private element;
    get isPopdown(): boolean;
    private jQueryElement?;
    private popdown?;
    private popdownOptions;
    set keepOpen(keepOpen: boolean);
    set trigger(trigger: any);
    set autoFocus(autoFocus: boolean);
    set toggleOnFocus(toggleOnFocus: boolean);
    /**
     * Hook to work with tabbing in and out of the popdown.
     */
    set firstLastTab(firstLastTab: any);
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    open(): void;
    close(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopDownDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoPopDownDirective, "[soho-popdown]", never, { "keepOpen": { "alias": "keepOpen"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "toggleOnFocus": { "alias": "toggleOnFocus"; "required": false; }; "firstLastTab": { "alias": "firstLastTab"; "required": false; }; }, {}, never, never, true, never>;
}

declare class SohoPopDownContentsComponent {
    get isPopDownContents(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopDownContentsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopDownContentsComponent, "soho-popdown-contents", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoPopDownModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopDownModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoPopDownModule, never, [typeof SohoPopDownContentsComponent, typeof SohoPopDownDirective], [typeof SohoPopDownContentsComponent, typeof SohoPopDownDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoPopDownModule>;
}

/**
 * SUB COMPONENT: SOHO-MENUPOPUPMENU-HEADING
 */
declare class SohoPopupMenuHeadingComponent {
    get isHeading(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuHeadingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopupMenuHeadingComponent, "li[soho-popupmenu-heading]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-POPUPMENU-SHORTCUT-TEXT
 */
declare class SohoPopupMenuShortCutTextComponent {
    get isShortCutText(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuShortCutTextComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopupMenuShortCutTextComponent, "span[soho-popupmenu-shortcut-text]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-MENUPOPUPMENU-SEPARATOR
 */
declare class SohoPopupMenuSeparatorComponent {
    get isSeparator(): boolean;
    singleSelectableSection: boolean;
    multiSelectableSection: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuSeparatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopupMenuSeparatorComponent, "li[soho-popupmenu-separator]", never, { "singleSelectableSection": { "alias": "singleSelectableSection"; "required": false; }; "multiSelectableSection": { "alias": "multiSelectableSection"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-MENUPOPUPMENU-LABEL
 */
declare class SohoPopupMenuItemLabelComponent {
    isDisabled?: boolean | null;
    get hrefAttr(): string;
    menuId?: string;
    menuUrl?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuItemLabelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopupMenuItemLabelComponent, "a[soho-popupmenu-label]", never, { "isDisabled": { "alias": "isDisabled"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; "menuUrl": { "alias": "menuUrl"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * SUB COMPONENT: SOHO-MENUPOPUPMENU-ITEM
 */
declare class SohoPopupMenuItemComponent implements OnChanges {
    isChecked?: boolean;
    isSelectable: boolean;
    isDisabled: boolean;
    isIndented: boolean;
    subMenu: boolean;
    menuItemLabel?: QueryList<SohoPopupMenuItemLabelComponent>;
    ngOnChanges(changes: SimpleChanges): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopupMenuItemComponent, "li[soho-popupmenu-item]", never, { "isChecked": { "alias": "isChecked"; "required": false; }; "isSelectable": { "alias": "isSelectable"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "isIndented": { "alias": "isIndented"; "required": false; }; "subMenu": { "alias": "subMenu"; "required": false; }; }, {}, ["menuItemLabel"], ["*"], true, never>;
}
declare class SohoPopupMenuComponent implements AfterViewInit, OnDestroy {
    private elementRef;
    private ngZone;
    set popupmenuOptions(_popupMenuOptions: SohoPopupMenuOptions);
    get popupmenuOptions(): SohoPopupMenuOptions;
    /** id (or jQuery object) of associated drop down list. */
    set menu(menu: string | JQuery);
    get menu(): string | JQuery;
    /** 'click' | 'rightClick' | 'immediate' */
    set trigger(trigger: SohoPopupMenuTrigger);
    get trigger(): SohoPopupMenuTrigger;
    /** Auto Focus */
    set autoFocus(autoFocus: boolean);
    get autoFocus(): boolean;
    /** Mouse focus. */
    set mouseFocus(mouseFocus: boolean);
    get mouseFocus(): boolean;
    /** Attach to body. */
    set attachToBody(attachToBody: boolean);
    get attachToBody(): boolean;
    /** beforeOpen - ajax callback for open event */
    set beforeOpen(beforeOpen: SohoPopupMenuSourceFunction);
    get beforeOpen(): SohoPopupMenuSourceFunction;
    /** Switches aria to use listbox construct instead of menu construct (internal). */
    set ariaListbox(ariaListbox: boolean);
    get ariaListbox(): boolean;
    /**
     * By default, menus open up underneath their target element.  Set this to true to
     * use mouse coordinates for positioning a menu inside of its target element.
     */
    set useCoordsForClick(useCoordsForClick: boolean);
    get useCoordsForClick(): boolean;
    /** Can pass in the event object so you can do a right click with immediate */
    set eventObj(eventObj: any);
    get eventObj(): any;
    set placementOpts(placementOpts: SohoPopupmenuPlacementOpts);
    get placementOpts(): SohoPopupmenuPlacementOpts;
    set offset(offset: SohoPopupmenuOffset);
    get offset(): SohoPopupmenuOffset;
    set removeOnDestroy(removeOnDestroy: boolean);
    get removeOnDestroy(): boolean;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /** If true, the menu stays open when clicking outside or pressing Escape/Tab */
    set keepOpen(keepOpen: boolean);
    get keepOpen(): boolean;
    selected: EventEmitter<SohoPopupMenuEvent>;
    popupmenuafterplace: EventEmitter<SohoPopupMenuEvent>;
    beforeopen: EventEmitter<SohoPopupMenuEvent>;
    /**
     * @todo remove override of native element
     */
    open: EventEmitter<SohoPopupMenuEvent>;
    afteropen: EventEmitter<SohoPopupMenuEvent>;
    closeEvent: EventEmitter<SohoPopupMenuEvent>;
    isPopupmenu: boolean;
    isSelectable: boolean;
    isMultiselectable: boolean;
    private jQueryElement?;
    private popupmenu?;
    private _popupMenuOptions;
    constructor(elementRef: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    /**
     * Returns the selected html element.
     */
    getSelected(): any;
    /**
     * Updates the control to reflect the settings.
     */
    updated(settings: any): void;
    /**
     * Tear down the markup for the popup menu
     */
    teardown(): void;
    /**
     * Closes the popup menu
     */
    close(isCancelled?: boolean, noFocus?: boolean): void;
    /**
     * Destroy the markup and any other resources.
     */
    destroy(): void;
    /**
     * Cleanup just before Angular destroys the component.
     * Unsubscribe observables, detach event handlers and remove other resources to avoid memory leaks.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPopupMenuComponent, "ul[soho-popupmenu]", never, { "popupmenuOptions": { "alias": "popupmenuOptions"; "required": false; }; "menu": { "alias": "menu"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "autoFocus": { "alias": "autoFocus"; "required": false; }; "mouseFocus": { "alias": "mouseFocus"; "required": false; }; "attachToBody": { "alias": "attachToBody"; "required": false; }; "beforeOpen": { "alias": "beforeOpen"; "required": false; }; "ariaListbox": { "alias": "ariaListbox"; "required": false; }; "useCoordsForClick": { "alias": "useCoordsForClick"; "required": false; }; "eventObj": { "alias": "eventObj"; "required": false; }; "placementOpts": { "alias": "placementOpts"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "removeOnDestroy": { "alias": "removeOnDestroy"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "keepOpen": { "alias": "keepOpen"; "required": false; }; "isSelectable": { "alias": "isSelectable"; "required": false; }; "isMultiselectable": { "alias": "isMultiselectable"; "required": false; }; }, { "selected": "selected"; "popupmenuafterplace": "popupmenuafterplace"; "beforeopen": "beforeopen"; "open": "open"; "afteropen": "afteropen"; "closeEvent": "close"; }, never, ["*"], true, never>;
}

declare class SohoPopupMenuModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPopupMenuModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoPopupMenuModule, never, [typeof SohoPopupMenuComponent, typeof SohoPopupMenuHeadingComponent, typeof SohoPopupMenuShortCutTextComponent, typeof SohoPopupMenuItemComponent, typeof SohoPopupMenuItemLabelComponent, typeof SohoPopupMenuSeparatorComponent], [typeof SohoPopupMenuComponent, typeof SohoPopupMenuHeadingComponent, typeof SohoPopupMenuShortCutTextComponent, typeof SohoPopupMenuItemComponent, typeof SohoPopupMenuItemLabelComponent, typeof SohoPopupMenuSeparatorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoPopupMenuModule>;
}

declare class SohoProgressComponent implements AfterViewInit, OnDestroy {
    private element;
    value?: number;
    set progressValue(value: number | undefined);
    get progressValue(): number | undefined;
    change?: EventEmitter<Object>;
    progressClass: boolean;
    get dispType(): string;
    private options;
    private jQueryElement?;
    private progress?;
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    update(value: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoProgressComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoProgressComponent, "soho-progress", never, { "progressValue": { "alias": "progressValue"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

declare class SohoProgressModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoProgressModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoProgressModule, never, [typeof SohoProgressComponent], [typeof SohoProgressComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoProgressModule>;
}

declare class SohoRadarComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isRadar(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any>);
    /** If false, the component will not resize when resizing the page. */
    set redrawOnResize(value: boolean);
    /** Makes it possible to adjust the top margins */
    set margin(value: Object);
    /** How many levels or inner circles should there be drawn. */
    set levels(value: number);
    /** What is the value that the biggest circle will represent */
    set maxValue(value: number);
    /** How far out than the outer circle should the labels be placed,
     * this may be useful to adjust for some charts. */
    set labelFactor(value: number);
    /**  The number of pixels after which a label needs to be
     * given a new line. You may want to change this based on label data. */
    set wrapWidth(value: number);
    /**  The opacity value of the blobs. */
    set opacityArea(value: number);
    /**  The size of the colored circles of each blog. Set to zero to remove dots. */
    set dotRadius(value: number);
    /**  The opacity of the circles of each blob 0 or .1 are good values. */
    set opacityCircles(value: number);
    /** The width of the stroke around each blob. */
    set strokeWidth(value: number);
    /** If true the area and stroke will follow a round path (cardinal-closed). */
    set roundStrokes(value: boolean);
    /** If false the axis lines will not be shown in the diagonals. */
    set showCrosslines(value: boolean);
    /** If false the axis labels will not be shown. */
    set showAxisLabels(value: boolean);
    /** An array of colors to use for each blob */
    set colors(value: any);
    /** If false no tooltips will be shown. */
    set showTooltips(value: boolean);
    /** A setting that controls the tooltip values and format. */
    set tooltip(value: SohoRadarTooltipOptions);
    /** d3 formatter to use on the axis labels */
    set axisFormatter(value: string);
    /**  If false the legend will not be shown. */
    set showLegend(value: boolean);
    /** Where to locate the legend. This can be bottom or right at the moment. */
    set legendPlacement(value: string);
    /**  An empty message will be displayed when there is no chart data. */
    set emptyMessage(value: SohoEmptyMessageOptions);
    /** Add extra attributes like id's to the component **/
    set attributes(value: Array<Object> | Object);
    selected: EventEmitter<SohoRadarSelectEvent>;
    unselected: EventEmitter<SohoRadarSelectEvent>;
    rendered: EventEmitter<Object>;
    dblclick: EventEmitter<Object>;
    /**
     * @todo remove override of native elements
     */
    contextmenu: EventEmitter<Object[]>;
    private jQueryElement?;
    private radar?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    setSelected(selected: SohoRadarSelected): void;
    toggleSelected(selected: SohoRadarSelected): void;
    getSelected(): Object | Object[] | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRadarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoRadarComponent, "[soho-radar]", never, { "dataset": { "alias": "dataset"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "levels": { "alias": "levels"; "required": false; }; "maxValue": { "alias": "maxValue"; "required": false; }; "labelFactor": { "alias": "labelFactor"; "required": false; }; "wrapWidth": { "alias": "wrapWidth"; "required": false; }; "opacityArea": { "alias": "opacityArea"; "required": false; }; "dotRadius": { "alias": "dotRadius"; "required": false; }; "opacityCircles": { "alias": "opacityCircles"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "roundStrokes": { "alias": "roundStrokes"; "required": false; }; "showCrosslines": { "alias": "showCrosslines"; "required": false; }; "showAxisLabels": { "alias": "showAxisLabels"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "showTooltips": { "alias": "showTooltips"; "required": false; }; "tooltip": { "alias": "tooltip"; "required": false; }; "axisFormatter": { "alias": "axisFormatter"; "required": false; }; "showLegend": { "alias": "showLegend"; "required": false; }; "legendPlacement": { "alias": "legendPlacement"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "selected": "selected"; "unselected": "unselected"; "rendered": "rendered"; "dblclick": "dblclick"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoRadarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRadarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoRadarModule, never, [typeof SohoRadarComponent], [typeof SohoRadarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoRadarModule>;
}

declare class SohoRatingComponent implements AfterViewInit, OnDestroy {
    private element;
    /** Options. */
    private settings;
    get isRating(): boolean;
    private jQueryElement?;
    private rating?;
    constructor(element: ElementRef);
    /** Setup */
    ngAfterViewInit(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    /** Make control read only **/
    readonly(): void;
    /** Enable the control **/
    enable(): void;
    /** Gets the current value of the control. If the control doesn't exist, will return -1 */
    get currentValue(): number;
    /** Sets the value for the control */
    set currentValue(newValue: number);
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRatingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoRatingComponent, "[soho-rating]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoRatingModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRatingModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoRatingModule, never, [typeof SohoRatingComponent], [typeof SohoRatingComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoRatingModule>;
}

/**
 * This component does not extend the ControlValueAccessor
 * as Angular already implements RadioControlValueAccessor
 * which hooks the controls up to the Forms model, see
 * https://angular.io/api/forms/RadioControlValueAccessor.
 *
 * The requirement is that the control matches the following
 * selector:
 *
 * input[type=radio][formControlName]
 * input[type=radio][formControl]
 * input[type=radio][ngModel]
 *
 * Make sure you add `type="radio"` to your markup.
 */
declare class SohoRadioButtonComponent implements AfterViewInit {
    private element;
    private ref;
    /** Current value. */
    value: any;
    /**
     * Called when the radiobutton value changes.
     *
     * @todo remove override of native element
     */
    change: EventEmitter<SohoRadioButtonEvent>;
    /** Bind attributes to the host input element. */
    get isRadioType(): string;
    /** Sets the class attribute for the radio button. */
    get isRadioButton(): boolean;
    /**
     * Due to conflicts with the ReactiveForms API, this Input
     * and HostBinding has been removed, in favour of using
     * [attr.disabled]="isDisabled".
     */
    set disabled(_value: boolean);
    /** Sets the element to indicate checked. */
    checked?: boolean;
    get tabIndex(): 0 | -1;
    /**
     * ---------------------------------------------------
     * Local variables
     * ---------------------------------------------------
     */
    /** JQuery Component */
    private jQueryElement?;
    /** Track whether the missing-name warning has already been logged. */
    private warnedMissingName;
    /**
     * Constructor.
     */
    constructor(element: ElementRef, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    onChange(event: SohoRadioButtonEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRadioButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoRadioButtonComponent, "input[soho-radiobutton]", never, { "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "checked": { "alias": "checked"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class SohoRadioButtonModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRadioButtonModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoRadioButtonModule, never, [typeof SohoRadioButtonComponent], [typeof SohoRadioButtonComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoRadioButtonModule>;
}

declare class SohoRenderLoopService {
    private ngZone;
    private renderLoopCount;
    constructor(ngZone: NgZone);
    /**
     * Start the entire render loop
     */
    start(): void;
    /**
     * Stops the entire render loop
     */
    stop(): void;
    getCurrentCount(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRenderLoopService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoRenderLoopService>;
}

declare class SohoRenderLoopModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoRenderLoopModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoRenderLoopModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoRenderLoopModule>;
}

declare class SohoSearchFieldModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSearchFieldModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSearchFieldModule, never, [typeof SohoSearchFieldComponent, typeof SohoSearchFieldWrapperComponent], [typeof SohoSearchFieldComponent, typeof SohoSearchFieldWrapperComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSearchFieldModule>;
}

declare class SohoSliderComponent extends BaseControlValueAccessor<number> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    private ref;
    /**
     * Flag to force an update of the control after the view is created.
     */
    private runUpdatedOnCheck?;
    /** Minimum Value */
    set min(min: number | undefined);
    get min(): number | undefined;
    /** Maximum Value */
    set max(max: number | undefined);
    get max(): number | undefined;
    /** Increment or decrement by step value */
    set step(step: number | undefined);
    get step(): number | undefined;
    /** value or a range of values */
    set value(value: number[] | undefined);
    get value(): number[] | undefined;
    /** Choose a range of values or select a value */
    set range(range: boolean | undefined);
    get range(): boolean | undefined;
    /** An array of ticks that provide the value, description and color details */
    set ticks(ticks: string);
    /** Persist tooltip */
    set persistTooltip(persistTooltip: boolean);
    /** Option to control the position of tooltip. ['top' , 'bottom'] */
    set tooltipPosition(tooltipPosition: 'top' | 'bottom');
    /** Tooltip Content */
    set tooltipContent(tooltipContent: string[]);
    /** Set vertical class to render the slider vertically */
    set vertical(isVertical: boolean);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /**
     * Called when the slider control changes
     *
     * @todo replace override of native element
     */
    change: EventEmitter<SohoSliderEvent>;
    /** Called when the slider is being slid */
    sliding: EventEmitter<SohoSliderEvent>;
    /** Called when the slider starts to be slid */
    slidestart: EventEmitter<SohoSliderEvent>;
    /** Called when the slider is finished sliding, change will also fire here. */
    slidestop: EventEmitter<SohoSliderEvent>;
    /** Called when the slider is updated when the model value changes */
    updated: EventEmitter<SohoSliderEvent>;
    /** Bind attributes to input element */
    get isSlider(): boolean;
    get isVerticalSlider(): boolean;
    get sliderType(): string;
    /**
     * Local variables
     */
    private isDisabled?;
    private isReadOnly?;
    private isVertical;
    private isVerticalOriginal;
    private jQueryElement?;
    private slider?;
    private options;
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef);
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    onChange(event: SohoSliderEvent): void;
    onSliding(event: SohoSliderEvent): void;
    onSlideStart(event: SohoSliderEvent): void;
    onSlideStop(event: SohoSliderEvent): void;
    onUpdated(event: SohoSliderEvent): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSliderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSliderComponent, "input[soho-slider]", never, { "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "value": { "alias": "value"; "required": false; }; "range": { "alias": "range"; "required": false; }; "ticks": { "alias": "ticks"; "required": false; }; "persistTooltip": { "alias": "persistTooltip"; "required": false; }; "tooltipPosition": { "alias": "tooltipPosition"; "required": false; }; "tooltipContent": { "alias": "tooltipContent"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "change": "change"; "sliding": "sliding"; "slidestart": "slidestart"; "slidestop": "slidestop"; "updated": "updated"; }, never, ["*"], true, never>;
}

declare class SohoSliderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSliderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSliderModule, never, [typeof SohoSliderComponent], [typeof SohoSliderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSliderModule>;
}

declare class SohoSparklineComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isSparkline(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Array<any>);
    /** Chart Type */
    set type(value: SohoSparklineType);
    /** An array of color sequences in hex format fx #1D5F8A, defaulting to the correct standard colors. */
    set colors(value: Array<any>);
    /** Shows dots on the data points. */
    set isDots(value: boolean);
    /** Highlights the top value as peak with a special dot. */
    set isPeakDot(value: boolean);
    /** Shows a continuous shading to highlight the min and max values. */
    set isMinMax(value: boolean);
    /** Adds a median range display. */
    set isMedianRange(value: boolean);
    rendered: EventEmitter<Object>;
    /**
     * @todo remove override of native element
     */
    contextmenu: EventEmitter<Object[]>;
    private jQueryElement?;
    private sparkline?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSparklineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSparklineComponent, "[soho-sparkline]", never, { "dataset": { "alias": "dataset"; "required": false; }; "type": { "alias": "type"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "isDots": { "alias": "isDots"; "required": false; }; "isPeakDot": { "alias": "isPeakDot"; "required": false; }; "isMinMax": { "alias": "isMinMax"; "required": false; }; "isMedianRange": { "alias": "isMedianRange"; "required": false; }; }, { "rendered": "rendered"; "contextmenu": "contextmenu"; }, never, ["*"], true, never>;
}

declare class SohoSparklineModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSparklineModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSparklineModule, never, [typeof SohoSparklineComponent], [typeof SohoSparklineComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSparklineModule>;
}

declare class SohoSpinboxComponent extends BaseControlValueAccessor<number> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Disabled flag - used by initialisation. */
    internalIsDisabled?: boolean;
    private runUpdatedOnCheck?;
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    /**
     * @todo replace override of native element
     */
    change: EventEmitter<number>;
    spinboxClass: boolean;
    get spinboxType(): string;
    id?: string;
    name?: string;
    min?: number;
    max?: number;
    /**
     * Value of the spin box.
     */
    set value(val: number | string | any);
    get value(): number | string | any;
    step?: number;
    /**
     * Allow empty values in the spinbox instead of defaulting to minimum value.
     * When true, the spinbox can be cleared completely.
     */
    set allowEmpty(value: boolean | undefined);
    /**
     * Gets the current allowEmpty setting.
     * @returns true if empty values are allowed, false otherwise
     */
    get allowEmpty(): boolean | undefined;
    set attrDisabled(_value: boolean);
    private options;
    private jQueryElement?;
    private spinbox?;
    updateVal(value: string | number): void;
    /**
     * Creates an instance of SohoSpinboxComponent.
     *
     * @param element matched element.
     * @param ngZone angular zone.
     *
     */
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    onChange(_event: SohoSpinboxEvent): void;
    /**
     * Override writeValue to allow the input element to be updated correctly.
     *
     * @param value the new value
     */
    writeValue(value: number): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSpinboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSpinboxComponent, "input[soho-spinbox]", never, { "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "value": { "alias": "value"; "required": false; }; "step": { "alias": "step"; "required": false; }; "allowEmpty": { "alias": "allowEmpty"; "required": false; }; "attrDisabled": { "alias": "attrDisabled"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class SohoSpinboxModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSpinboxModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSpinboxModule, never, [typeof SohoSpinboxComponent], [typeof SohoSpinboxComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSpinboxModule>;
}

/**
 * Angular Wrapper for the Soho  Splitter Control.
 *
 * This component searches for an element with the name
 * 'soho-splitter' in the parent's DOM tree, initialising it with
 * the Soho Splitter control.
 */
declare class SohoSplitterComponent implements AfterViewInit, OnDestroy {
    private element;
    private options;
    set axis(axis: SohoSplitterOptionsAxis);
    set resize(resize: SohoSplitterOptionsResize);
    set containment(containment: JQuery);
    set collapseButton(collapseButton: boolean);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /** Ability to stop dragging at a max left or right size. **/
    set maxWidth(maxWidth: SohoSplitterOptionsMaxWidth);
    set save(save: boolean);
    split: EventEmitter<Object[]>;
    isSplitter: boolean;
    isSplitterRight: boolean | undefined;
    private jQueryElement?;
    private splitter?;
    /**
     * Constructor.
     *
     * @parm element - the element representing the splitter on the page.
     */
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSplitterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSplitterComponent, "soho-splitter", never, { "axis": { "alias": "axis"; "required": false; }; "resize": { "alias": "resize"; "required": false; }; "containment": { "alias": "containment"; "required": false; }; "collapseButton": { "alias": "collapseButton"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "save": { "alias": "save"; "required": false; }; "isSplitterRight": { "alias": "isSplitterRight"; "required": false; }; }, { "split": "split"; }, never, ["*"], true, never>;
}

declare class SohoSplitterModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSplitterModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSplitterModule, never, [typeof SohoSplitterComponent], [typeof SohoSplitterComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSplitterModule>;
}

declare class SohoStepChartComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    private options;
    get isStepChart(): boolean;
    /** The number of steps to show. */
    set steps(steps: number);
    /** The number of steps complete (linear). */
    set completed(completed: number);
    /** The number of the in progress step (linear). */
    set inProgress(inProgress: number);
    /** The icon to display fx. 'icon-error', 'icon-success' */
    set iconType(iconType: boolean);
    /**
     * The completed text or uses a localized 'N of N Steps complete'.
     *  You can use {0} and {1} to replace n of n in the string.
     */
    set completedText(completedText: string);
    /**
     * The additional text to show on the right. Defaults to none.
     * You can use {0} to replace with the steps remaining count and {1} to replace the number of steps.
     */
    set extraText(extraText: string);
    /** The color to show completed steps. Defaults to primary color. */
    set completedColor(completedColor: string);
    /** The color to steps when all are completed. Defaults to primary color. */
    set allCompletedColor(allCompletedColor: string);
    /** The color to show in-progress steps. Defaults to ruby02. */
    set inProgressColor(inProgressColor: string);
    /** Add extra attributes like id's to the chart elements.
     * For example { name: 'id', value: 'my-unique-id' }
     */
    set attributes(attributes: Array<Object> | Object);
    private jQueryElement?;
    private stepchart?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepChartComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepChartComponent, "[soho-stepchart]", never, { "steps": { "alias": "steps"; "required": false; }; "completed": { "alias": "completed"; "required": false; }; "inProgress": { "alias": "inProgress"; "required": false; }; "iconType": { "alias": "iconType"; "required": false; }; "completedText": { "alias": "completedText"; "required": false; }; "extraText": { "alias": "extraText"; "required": false; }; "completedColor": { "alias": "completedColor"; "required": false; }; "allCompletedColor": { "alias": "allCompletedColor"; "required": false; }; "inProgressColor": { "alias": "inProgressColor"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoStepChartModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepChartModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoStepChartModule, never, [typeof SohoStepChartComponent], [typeof SohoStepChartComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoStepChartModule>;
}

/**************************************************************
 * STEP LIST TITLE
 **************************************************************/
declare class SohoStepListTitleComponent {
    get title(): boolean;
    get titleWide(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepListTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepListTitleComponent, "div[soho-step-list-title]", never, {}, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP LIST
 **************************************************************/
declare class SohoStepListComponent {
    isTree: boolean;
    isJSStepTreeScroll: boolean;
    id: string;
    dataInit: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepListComponent, "ul[soho-step-list]", never, {}, {}, never, ["*"], true, never>;
}
/**************************************************************
 * SUB STEP LIST
 **************************************************************/
declare class SohoSubstepListComponent {
    isFolder: boolean;
    isJSStepFolder: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSubstepListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSubstepListComponent, "ul[soho-substep-list]", never, {}, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP LIST ITEM
 **************************************************************/
declare class SohoStepListItemComponent {
    get jsStep(): boolean;
    isSelected: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepListItemComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepListItemComponent, "li[soho-step-list-item]", never, { "isSelected": { "alias": "isSelected"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP LIST ITEM ANCHOR
 **************************************************************/
declare class SohoStepListItemAnchorComponent {
    isJsStepLink: boolean;
    get hrefAttr(): string | null;
    stepId?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepListItemAnchorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepListItemAnchorComponent, "a[soho-step-list-item-anchor]", never, { "stepId": { "alias": "stepId"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP LIST ITEM TITLE
 **************************************************************/
declare class SohoStepListItemTitleComponent {
    treeText: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepListItemTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepListItemTitleComponent, "span[soho-step-list-item-title]", never, {}, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP CONTENT TITLE
 **************************************************************/
declare class SohoStepContentTitleComponent {
    isHeading: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepContentTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepContentTitleComponent, "div[soho-step-content-title]", never, {}, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP CONTENT
 **************************************************************/
declare class SohoStepContentComponent {
    get isScrollable(): boolean;
    get iStepContainer(): boolean;
    get isJsStepPanelsScroll(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepContentComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepContentComponent, "div[soho-step-content]", never, {}, {}, never, ["*"], true, never>;
}
/**************************************************************
 * STEP CONTENT PANEL
 **************************************************************/
declare class SohoStepContentPanelComponent {
    get isJsStepProcessPanel(): boolean;
    get idAttr(): string | undefined;
    stepId?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepContentPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepContentPanelComponent, "div[soho-step-content-panel]", never, { "stepId": { "alias": "stepId"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class SohoStepProcessComponent implements AfterViewInit, OnDestroy {
    private element;
    isStepProcessContainer: boolean;
    isTwoColumn: boolean;
    isFixed: boolean;
    isPageContainer: boolean;
    isNoScroll: boolean;
    /**
     * Whether or not to restrict navigation to next and previous buttons only.
     */
    set linearProgression(linearProgression: boolean);
    nextButtonLabel: string;
    previousButtonLabel: string;
    saveAndCloseButtonLabel: string;
    continueButtonLabel: string;
    nextButtonAriaLabel: string;
    previousButtonAriaLabel: string;
    continueButtonAriaLabel: string;
    saveAndCloseButtonAriaLabel: string;
    set nextButtonEnable(enabled: boolean);
    set previousButtonEnable(enabled: boolean);
    set saveCloseButtonEnable(enabled: boolean);
    beforeSelectStep: EventEmitter<BeforeSelectStepEvent>;
    saveClose: EventEmitter<SohoStepSaveCloseEvent>;
    private jQueryElement?;
    private stepprocess?;
    private stepProcessOptions;
    private beforeSelectStepDeferred;
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    private beforeSelectStepPromise;
    private beforeSelectStepResponse;
    private fireOnSaveClose;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepProcessComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoStepProcessComponent, "div[soho-stepprocess]", never, { "linearProgression": { "alias": "linearProgression"; "required": false; }; "nextButtonLabel": { "alias": "nextButtonLabel"; "required": false; }; "previousButtonLabel": { "alias": "previousButtonLabel"; "required": false; }; "saveAndCloseButtonLabel": { "alias": "saveAndCloseButtonLabel"; "required": false; }; "continueButtonLabel": { "alias": "continueButtonLabel"; "required": false; }; "nextButtonAriaLabel": { "alias": "nextButtonAriaLabel"; "required": false; }; "previousButtonAriaLabel": { "alias": "previousButtonAriaLabel"; "required": false; }; "continueButtonAriaLabel": { "alias": "continueButtonAriaLabel"; "required": false; }; "saveAndCloseButtonAriaLabel": { "alias": "saveAndCloseButtonAriaLabel"; "required": false; }; "nextButtonEnable": { "alias": "nextButtonEnable"; "required": false; }; "previousButtonEnable": { "alias": "previousButtonEnable"; "required": false; }; "saveCloseButtonEnable": { "alias": "saveCloseButtonEnable"; "required": false; }; }, { "beforeSelectStep": "beforeSelectStep"; "saveClose": "saveClose"; }, never, ["div[soho-step-list-title]", "ul[soho-step-list]", "div[soho-step-content-title]", "div[soho-step-content]"], true, never>;
}

declare class SohoStepProcessModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoStepProcessModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoStepProcessModule, never, [typeof SohoStepListComponent, typeof SohoStepListTitleComponent, typeof SohoStepListItemComponent, typeof SohoStepListItemAnchorComponent, typeof SohoStepListItemTitleComponent, typeof SohoSubstepListComponent, typeof SohoStepContentTitleComponent, typeof SohoStepContentComponent, typeof SohoStepContentPanelComponent, typeof SohoStepProcessComponent], [typeof SohoStepListComponent, typeof SohoStepListTitleComponent, typeof SohoStepListItemComponent, typeof SohoStepListItemAnchorComponent, typeof SohoStepListItemTitleComponent, typeof SohoSubstepListComponent, typeof SohoStepContentTitleComponent, typeof SohoStepContentComponent, typeof SohoStepContentPanelComponent, typeof SohoStepProcessComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoStepProcessModule>;
}

/**
 * Dynamic Soho SwapList Service contract.
 */
declare abstract class SohoSwapListService {
    /**
     * Returns a list of <SohoSwapListOptions> data.
     */
    abstract getData(): Observable<SohoSwapListOptions>;
}

type SohoSwapListCardType = 'available' | 'selected' | 'full-access';
/**************************************************************
 * SWAP LIST CARD
 **************************************************************/
declare class SohoSwapListCardComponent {
    get isSwapList(): boolean;
    /** The type of card. */
    private cardtype?;
    /** The title for the card. */
    private cardtitle?;
    /** The show searchable for the search-field. */
    private showsearchable?;
    /** The show searchable for the search-field. */
    private searchtitle?;
    set type(value: SohoSwapListCardType);
    set showSearchable(value: boolean | undefined);
    get showSearchable(): boolean | undefined;
    set searchTitle(value: string | undefined);
    get searchTitle(): string | undefined;
    /**
     * Return the class to use for the card.
     */
    get cardClass(): string;
    /**
     * Return the card type to use for the card.
     */
    get cardType(): string;
    /**
     * Title of the card, e.g. 'Available'.
     */
    set title(value: string | undefined);
    get title(): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSwapListCardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSwapListCardComponent, "soho-swaplist-card", never, { "type": { "alias": "type"; "required": false; }; "showSearchable": { "alias": "showSearchable"; "required": false; }; "searchTitle": { "alias": "searchTitle"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**************************************************************
 * SWAP LIST
 **************************************************************/
declare class SohoSwapListComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    private swaplistService;
    /** Used to provide unnamed controls with a unique id. */
    private static counter;
    /** Selector for originating element. */
    private jQueryElement?;
    /** Reference to the SoHoXi control api. */
    private swaplist?;
    /** Block of options, use the accessors to modify. */
    private _options;
    /** Flag controlling the display of the full access (additional) items. */
    private _showFullAccessCard;
    /**
     * Assign the id for the control
     * (maps to the name to use on a label's 'for' attribute)
     */
    get id(): string;
    /** Adds the 'swaplist' class required by the SoHoXi control. */
    get isSwapList(): boolean;
    /** Adds the 'one-third' class required when full access is set. */
    get isOneThird(): boolean;
    /** The component used to represent the available items. */
    _availableCard?: SohoSwapListCardComponent;
    /** The component used to represent the selected items. */
    _selectedCard?: SohoSwapListCardComponent;
    /** The component used to represent the full access (additional) items. */
    _additionalCard?: SohoSwapListCardComponent;
    /** Name for the swaplist control. Necessary for ngModel to function. */
    name: string;
    /** Default title for available items card. */
    availableCardTitle: string;
    /** Default title for selected items card. */
    selectedCardTitle: string;
    /** Default title for additional items card. */
    fullAccessCardTitle: string;
    /** Default search title for available items card. */
    availableCardSearchTitle: string;
    /** Default search title for selected items card. */
    selectedCardSearchTitle: string;
    /** Default search title for additional items card. */
    fullAccessCardSearchTitle: string;
    /** Default button text for select. */
    btnMoveToSelect: string;
    /** Default button text for move to left. */
    btnMoveToLeft: string;
    /** Default button text for  move to right. */
    btnMoveToRight: string;
    /**
     * Set searchable option for SohoSwapList.
     *
     * @param value option.
     */
    set searchable(value: boolean | undefined);
    get searchable(): boolean | undefined;
    /** Add extra attributes like id's to the component **/
    set attributes(value: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    /**
     * Set available card items.
     * @param value item data.
     */
    set availableItems(value: SohoSwapListItem[] | undefined);
    get availableItems(): SohoSwapListItem[] | undefined;
    /** Disable dragging (all true by default) **/
    set draggable(value: SohoSwapSections | undefined);
    get draggable(): SohoSwapSections | undefined;
    /** Keep items in the section when moving (all false by default) **/
    set keepInList(value: SohoSwapSections | undefined);
    get keepInList(): SohoSwapSections | undefined;
    /**
     * Set selected card items.
     *
     * @param value item data.
     */
    set selectedItems(value: SohoSwapListItem[]);
    /**
     * Return the dataset currently selected card items.
     *
     * @return an array of SohoSwapListItem.
     */
    get selectedItems(): SohoSwapListItem[];
    /**
     * Set additional card items.
     *
     * @param value item data.
     */
    set additionalItems(value: SohoSwapListItem[]);
    /**
     * Return the dataset currently additional card items.
     *
     * @return an array of SohoSwapListItem.
     */
    get additionalItems(): SohoSwapListItem[];
    /**
     * Set flag to display third card full access card or not.
     *
     * @param value the value to show full access card.
     */
    set showFullAccessCard(value: boolean);
    /**
     * Return the value whether full access card displayed.
     *
     * @return boolean value.
     */
    get showFullAccessCard(): boolean;
    /**
     * Called before swap item/s.
     */
    beforeSwapEvent: EventEmitter<SohoSwapListBeforeSwapEvent>;
    /**
     * Called when the swap list updates in some way.
     */
    updateEvent: EventEmitter<SohoSwapListSwapUpdateEvent>;
    constructor(element: ElementRef, ngZone: NgZone, swaplistService: SohoSwapListService);
    ngAfterViewInit(): void;
    /**
     * Destroys any resources created by the control.
     */
    ngOnDestroy(): void;
    /**
     * In case the list data is being bound asynchronously or modified on the fly,
     * you will need to trigger updated on so it updates the list(s).
     */
    updated(): void;
    /**
     * Updates the dataset used by the swaplist, dynamically refesing the
     * control's view.
     *
     * @param dataset the dataset to assign.
     */
    updateDataset(dataset: SohoSwapListOptions): void;
    /**
     * Converts the list of items into a list of swaplist items.
     *
     * @param items data to convert to item model.
     *
     * @todo remove any
     */
    private ConvertToModel;
    private onBeforeSwap;
    private onSwapUpdate;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSwapListComponent, [null, null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSwapListComponent, "soho-swaplist", never, { "name": { "alias": "name"; "required": false; }; "availableCardTitle": { "alias": "availableCardTitle"; "required": false; }; "selectedCardTitle": { "alias": "selectedCardTitle"; "required": false; }; "fullAccessCardTitle": { "alias": "fullAccessCardTitle"; "required": false; }; "availableCardSearchTitle": { "alias": "availableCardSearchTitle"; "required": false; }; "selectedCardSearchTitle": { "alias": "selectedCardSearchTitle"; "required": false; }; "fullAccessCardSearchTitle": { "alias": "fullAccessCardSearchTitle"; "required": false; }; "btnMoveToSelect": { "alias": "btnMoveToSelect"; "required": false; }; "btnMoveToLeft": { "alias": "btnMoveToLeft"; "required": false; }; "btnMoveToRight": { "alias": "btnMoveToRight"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "availableItems": { "alias": "availableItems"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "keepInList": { "alias": "keepInList"; "required": false; }; "selectedItems": { "alias": "selectedItems"; "required": false; }; "additionalItems": { "alias": "additionalItems"; "required": false; }; "showFullAccessCard": { "alias": "showFullAccessCard"; "required": false; }; }, { "beforeSwapEvent": "beforeswap"; "updateEvent": "updated"; }, ["_availableCard", "_selectedCard", "_additionalCard"], never, true, never>;
}

declare class SohoSwapListModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSwapListModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSwapListModule, never, [typeof SohoSwapListCardComponent, typeof SohoSwapListComponent], [typeof SohoSwapListCardComponent, typeof SohoSwapListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSwapListModule>;
}

declare class SohoSwipeActionComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    /** Options */
    private swipeaction?;
    private jQueryElement;
    get isSwipeAction(): boolean;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    updated(settings: any): SohoSwipeActionComponent;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSwipeActionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSwipeActionComponent, "[soho-swipe-action]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoSwipeActionModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSwipeActionModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoSwipeActionModule, never, [typeof SohoSwipeActionComponent], [typeof SohoSwipeActionComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoSwipeActionModule>;
}

/**
 * Support Tag types.
 *
 * `error` displayed as an error (for example with a red background).
 * `good` displayed to mean correct or valid (for example with a green background).
 * `alert` displayed as an alert (for example with a yellow background).
 * `secondary` displayed as grey - like a secondary button.
 *
 * Leaving the value off the element displays the element in it's default state.
 *
 * Note: You should not use color alone to indicate state, this should be either
 * supplemented with off-screen labels or visual labels near the element explaining the state.
 */
type SohoTagType = 'error' | 'good' | 'alert' | 'secondary' | 'info' | undefined;
declare class SohoTagListComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    get isTagList(): boolean;
    /**
     * Fired before a tag item is removed.
     */
    beforeRemove: EventEmitter<SohoTagBeforeRemoveEvent>;
    /**
     * Fired after a tag item is removed.
     */
    afterRemove: EventEmitter<SohoTagAfterRemoveEvent>;
    /**
     * The wrapped jQuery element.
     */
    private jQueryElement?;
    /**
     * Creates an instance of SohoTagListComponent.
     *
     * @param element wrapped element.
     * @param ngZone angular zone.
     *
     */
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    private onAfterTagRemove;
    private onBeforeTagRemove;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTagListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTagListComponent, "[soho-tag-list]", never, {}, { "beforeRemove": "beforeRemove"; "afterRemove": "afterRemove"; }, never, ["*"], true, never>;
}
/**
 * Angular Support for elements styled as SohoXi tags.  The styling can be
 * controlled using the additional tag type, specified on element.
 *
 * They can be mixed in with other elements like lists, grids and search fields.
 *
 *<pre>
 * {@code
 * <span soho-tag='error'>#Error</span>
 * }
 *</pre>
 *
 * @export
 *
 *
 *
 */
declare class SohoTagComponent implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    static ALERT: SohoTagType;
    static GOOD: SohoTagType;
    static SECONDARY: SohoTagType;
    static ERROR: SohoTagType;
    static INFO: SohoTagType;
    static DEFAULT: SohoTagType;
    /**
     * Fired before a tag item is removed.
     */
    beforeTagRemove: EventEmitter<SohoTagBeforeRemoveEvent>;
    /**
     * Fired after a tag item is removed.
     *
     * @todo remove usage of native element
     */
    click: EventEmitter<SohoTagAfterRemoveEvent>;
    /** Options. */
    private options;
    get isTag(): boolean;
    get alert(): boolean;
    get good(): boolean;
    get secondary(): boolean;
    get error(): boolean;
    get info(): boolean;
    isClickable?: boolean;
    isDismissible?: boolean;
    /**
     * Allow override of element name, to match the component name.
     */
    set sohoTag(type: SohoTagType | '');
    private tagType;
    private jQueryElement?;
    tag?: SohoTag | null;
    /**
     * Creates an instance of SohoTagComponent.
     */
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    private onBeforeTagRemove;
    private onClick;
    /**
     * The settings have been updated.
     */
    updated(): void;
    /**
     * Destroys the component.
     *
     *
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTagComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTagComponent, "[soho-tag]", never, { "isClickable": { "alias": "isClickable"; "required": false; }; "isDismissible": { "alias": "isDismissible"; "required": false; }; "sohoTag": { "alias": "soho-tag"; "required": false; }; }, { "beforeTagRemove": "beforeTagRemove"; "click": "click"; }, never, ["*"], true, never>;
}

declare class SohoTagModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTagModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTagModule, never, [typeof SohoTagComponent, typeof SohoTagListComponent], [typeof SohoTagComponent, typeof SohoTagListComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTagModule>;
}

/**
 * Internal component to support the tab title
 */
declare class SohoTabTitleComponent {
    get hrefAttr(): string;
    tabId?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabTitleComponent, "a[soho-tab-title]", never, { "tabId": { "alias": "tabId"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Internal component to support the tab with a 'count' on it.
 */
declare class SohoTabCountComponent {
    constructor(_element: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabCountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabCountComponent, "span[soho-tab-count]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Internal component to support a divider between tab items
 */
declare class SohoTabSeparatorComponent {
    constructor(_element: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabSeparatorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabSeparatorComponent, "li[soho-tab-separator]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Internal component to support tab panel container content.
 */
declare class SohoTabPanelContainerComponent {
    private element;
    constructor(element: ElementRef);
    verticalScrolling: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabPanelContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabPanelContainerComponent, "div[soho-tab-panel-container]", never, { "verticalScrolling": { "alias": "verticalScrolling"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Internal component to support tab panel content.
 */
declare class SohoTabPanelComponent {
    constructor(_element: ElementRef);
    tabId?: string;
    contained?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabPanelComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabPanelComponent, "div[soho-tab-panel]", never, { "tabId": { "alias": "tabId"; "required": false; }; "contained": { "alias": "contained"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Internal component to support the tab list items
 */
declare class SohoTabComponent implements OnChanges {
    private _element;
    private _selected;
    constructor(_element: ElementRef);
    dismissible: boolean;
    disabled: boolean;
    hidden: boolean;
    hasPopupMenu: boolean;
    get selected(): boolean;
    set selected(value: boolean);
    ngOnChanges(changes: SimpleChanges): void;
    private updateAriaSelected;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabComponent, "li[soho-tab]", never, { "dismissible": { "alias": "dismissible"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "hasPopupMenu": { "alias": "hasPopupMenu"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Tabset header component
 */
declare class SohoTabListComponent {
    constructor(_element: ElementRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabListComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabListComponent, "ul[soho-tab-list]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Tabset header component
 */
declare class SohoTabListContainerComponent {
    constructor(_element: ElementRef);
    verticalScrolling: any;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabListContainerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabListContainerComponent, "div[soho-tab-list-container]", never, { "verticalScrolling": { "alias": "verticalScrolling"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * soho-tabs component
 */
declare class SohoTabsComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    get isVertical(): boolean;
    get isModuleTabs(): boolean;
    get isHeaderTabs(): boolean;
    get isAlternate(): boolean;
    /**
     * set to true to show a secondary style for the tabs
     *
     */
    alternate: boolean;
    /**
     * set to true to display the tabs vertically to the left of the tab-panel
     *
     */
    vertical: boolean;
    /**
     * set to true to display the tabs as module tabs
     *
     */
    moduleTabs: boolean;
    /**
     * set to true to display the tabs as header tabs
     *
     */
    headerTabs: boolean;
    /**
     * The callback function called before a tab is closed.
     * Return false to prevent the tab from closing.
     */
    beforeCloseCallback?: Function;
    set tabsOptions(tabsOptions: SohoTabsOptions);
    /**
     * If set to true, creates a button at the end of the tab list that can be used to add an empty tab and panel.
     */
    set activateOnAdd(activateOnAdd: boolean);
    /**
     * If set to true, creates a button at the end of the tab list that can be used to add an empty tab and panel.
     */
    set addTabButton(addTabButton: boolean);
    /**
     * if defined as a function, will be used in-place of the default Tab Adding method
     * TODO: how to handle call back function?
     */
    set addTabButtonCallback(addTabButtonCallback: Function);
    /**
     * If set to true, will force an App Menu trigger to be present on Non-Vertical Tabs implementatations.
     */
    set appMenuTrigger(appMenuTrigger: boolean);
    /**
     * If defined, replaces the default "Menu" text used in the app menu trigger.
     */
    set appMenuTriggerText(appMenuTriggerText: string);
    /**
     *  If true, causes an app menu trigger's text content to be visually hidden (but still exists for accessiblity purposes)
     */
    set appMenuTriggerTextAudible(appMenuTriggerTextAudible: boolean);
    /**
     *  If defined, will be used by any internal Tabs AJAX calls as the desired request settings.
     */
    set ajaxOptions(ajaxOptions: object);
    /**
     * Defines a separate element to be used for containing the tab panels.  Defaults to the Tab Container itself
     */
    set containerElement(containerElement: string);
    /**
     * If true, will change the selected tab on invocation based on the URL that exists after the hash
     *
     */
    set changeTabOnHashChange(changeTabOnHashChange: boolean);
    /**
     * If true, will change the selected tab on invocation based on the URL that exists after the hash
     *
     */
    set maxWidth(width: number);
    /**
     * If defined as a function, provides an external method for adjusting the current page hash used by these tabs
     * TODO: how to handle call back function?
     */
    set hashChangeCallback(hashChangeCallback: Function);
    /**
     * If true, when using full URLs in tab HREFs, or when using Ajax calls, tabs will be loaded as needed instead of the markup
     * all being established at once.
     */
    set lazyLoad(lazyLoad: boolean);
    /**
     * If true, will display a tooltip or Module Tabs with cut-off text content.
     */
    set moduleTabsTooltips(moduleTabsTooltips: boolean);
    /**
     * If true, will display a tooltip on Multi Tabs with cut-off text content.
     */
    set multiTabsTooltips(multiTabsTooltips: boolean);
    /**
     * If defined, it will display the position of counts.
     */
    set countsPosition(countsPosition: undefined | 'top' | 'bottom');
    /**
     * If defined, will serve as a way of pulling in external content to fill tabs.
     */
    set source(source: Function);
    /**
     * If a source method is defined, this flexible object can be passed into the source method, and augmented with
     * parameters specific to the implementation.
     */
    set sourceArguments(sourceArguments: Function);
    /**
     * set to true to allow tab count markup <span class=tabcount>#</span>.
     *
     */
    set tabCounts(tabCounts: boolean);
    /**
     * set to true to allow tab count markup <span class=tabcount>#</span>.
     *
     */
    set anchorFocus(anchorFocus: boolean);
    /**
     * If Vertical Tabs & true, will automatically switch to Horizontal Tabs on smaller breakpoints.
     *
     */
    set verticalResponsive(verticalResponsive: boolean);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /** Sets the tabs to be sortable by drag and drop. **/
    set sortable(sortable: boolean);
    /** If false then error icon will not appear when validator is running */
    set validate(validate: boolean);
    /**
     * if you would like to run the updated() function yourself instead of having
     * this tabs component check for you set this input to true. The advantage to
     * this is that if you know when to update you can be more efficient.
     */
    disableAutoUpdatedCall: boolean;
    /**
     * The beforeactivated event is fired whenever a tab is selected giving the event handler a chance
     * to "veto" the tab selection change.
     *
     */
    beforeActivated: EventEmitter<SohoTabsEvent>;
    /**
     * The beforeactivate event is deprecated in favor of `beforeactivated`.
     *
     * @deprecated
     */
    beforeActivate: DeprecatedEventEmitter<SohoTabsEvent>;
    /**
     * The activated event is fired whenever a tab is selected (or "activated");
     */
    activated: EventEmitter<SohoTabsEvent>;
    /**
     * The afteractivate event is fired after the has been activated.
     */
    afterActivated: EventEmitter<SohoTabsEvent>;
    /**
     * fired before a tab closes
     */
    beforeClose: EventEmitter<SohoTabsEvent>;
    /**
     * fired when a tab closes
     *
     * @todo replace override of native element
     */
    close: EventEmitter<SohoTabsEvent>;
    /**
     * fired after a tab closes
     */
    afterClose: EventEmitter<SohoTabsEvent>;
    /**
     * fire when a new tab is added.
     *
     */
    tabAdded: EventEmitter<SohoTabsEvent>;
    private jQueryElement?;
    private tabs?;
    private _tabsOptions;
    /**
     * Keep track of current tab content for change detection.
     * If the number of tab change we must call tabs.updated() to
     * rebuild teh jquery tab control, if only the titles changed
     * then we can call tabs.handleResize to update the selection
     * style and the overflow.
     * NOTE: only used when disableAutoUpdatedCall is false
     */
    private tabCount?;
    /**
     * NOTE: only used when disableAutoUpdatedCall is false
     */
    private tabIds?;
    /**
     * NOTE: only used when disableAutoUpdatedCall is false
     */
    private tabTitles?;
    /**
     * set to true when @input changes. This will cause the tabs.updated call
     * in the afterViewChecked. This technique has the advantage of only calling
     * updated once in the current angular cycle no matter how many inputs are
     * changed during that cycle.
     */
    private updateRequired;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching the component's selector.
     */
    constructor(_changeDetectorRef: ChangeDetectorRef, element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    private updateTabInfo;
    private getTabLiList;
    private getActivatedTab;
    private getTabIds;
    private getTabTitles;
    /**
     * Causes the tabs component view to be rebuilt
     */
    updated(): void;
    /**
     * @param tab The tab element in the list that needs to be activated
     * @returns
     */
    activateTab(tab: string | JQuery | undefined): void;
    /**
     * Call resize manually when tab titles change so that the underline width matches.
     */
    handleResize(doResponsiveCheck?: boolean): void;
    /**
     * Manually call updated and refresh out of the zone.
     */
    refresh(): void;
    /**
     * Adds a new tab into the tab component
     *
     * @param tabId The tabId of the tab to be added
     * @param options ?
     * @param atIndex The index location where the tab is to be added.
     */
    add(tabId: string, options: any, atIndex: number): void;
    /**
     * Removes a tab
     *
     * @param tabId The tabId of the tab to be removed.
     * @param disableBeforeClose If true, the beforeClose callback should be called
     * before removing the tab.
     */
    remove(tabId: string, disableBeforeClose?: boolean): void;
    /**
     * Hides a tab for the given tabId
     *
     * @param tabId The id of the tab to hide
     */
    hide(tabId: string): void;
    show(tabId: string): void;
    disableTab(tabId: number): void;
    enableTab(tabId: number): void;
    rename(tabId: string, name: string): void;
    /**
     * Gets a tab given either an event or a tabId
     *
     * @param event And event from a tab that will allow tab retrieval
     * @param tabId The tabId of the tab to be retrieved.
     */
    getTab(event: SohoTabsEvent, tabId: string): any;
    /**
     * Return the currenlty active/selected tab.
     *
     * @return  A JQuery object of the active tab element.
     */
    getActiveTab(): JQuery;
    /**
     * Returns the visible tabs
     *
     * @return  An array of JQuery objects of the visible tab elements
     */
    getVisibleTabs(): Array<JQuery>;
    /**
     * Returns the overflow tabs
     *
     * @return  An array of JQuery objects of the overflow tab elements
     */
    getOverflowTabs(): Array<JQuery>;
    /**
     * Selects the tab given an href
     *
     * @param href an href used to find the tab to select
     * @param noFocus true to prevent focus
     */
    select(href: string, noFocus?: boolean): void;
    /**
     * Disables the entire tab component
     */
    disable(): void;
    /**
     * enables the entire tab component
     */
    enable(): void;
    private onBeforeActivated;
    private onActivated;
    private onAfterActivated;
    private onBeforeClose;
    private onClose;
    private onAfterClose;
    private onTabAdded;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTabsComponent, "div[soho-tabs]", never, { "alternate": { "alias": "alternate"; "required": false; }; "vertical": { "alias": "vertical"; "required": false; }; "moduleTabs": { "alias": "moduleTabs"; "required": false; }; "headerTabs": { "alias": "headerTabs"; "required": false; }; "beforeCloseCallback": { "alias": "beforeCloseCallback"; "required": false; }; "tabsOptions": { "alias": "tabsOptions"; "required": false; }; "activateOnAdd": { "alias": "activateOnAdd"; "required": false; }; "addTabButton": { "alias": "addTabButton"; "required": false; }; "addTabButtonCallback": { "alias": "addTabButtonCallback"; "required": false; }; "appMenuTrigger": { "alias": "appMenuTrigger"; "required": false; }; "appMenuTriggerText": { "alias": "appMenuTriggerText"; "required": false; }; "appMenuTriggerTextAudible": { "alias": "appMenuTriggerTextAudible"; "required": false; }; "ajaxOptions": { "alias": "ajaxOptions"; "required": false; }; "containerElement": { "alias": "containerElement"; "required": false; }; "changeTabOnHashChange": { "alias": "changeTabOnHashChange"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "hashChangeCallback": { "alias": "hashChangeCallback"; "required": false; }; "lazyLoad": { "alias": "lazyLoad"; "required": false; }; "moduleTabsTooltips": { "alias": "moduleTabsTooltips"; "required": false; }; "multiTabsTooltips": { "alias": "multiTabsTooltips"; "required": false; }; "countsPosition": { "alias": "countsPosition"; "required": false; }; "source": { "alias": "source"; "required": false; }; "sourceArguments": { "alias": "sourceArguments"; "required": false; }; "tabCounts": { "alias": "tabCounts"; "required": false; }; "anchorFocus": { "alias": "anchorFocus"; "required": false; }; "verticalResponsive": { "alias": "verticalResponsive"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "validate": { "alias": "validate"; "required": false; }; "disableAutoUpdatedCall": { "alias": "disableAutoUpdatedCall"; "required": false; }; }, { "beforeActivated": "beforeActivated"; "beforeActivate": "beforeActivate"; "activated": "activated"; "afterActivated": "afterActivated"; "beforeClose": "beforeClose"; "close": "close"; "afterClose": "afterClose"; "tabAdded": "tabAdded"; }, never, ["*"], true, never>;
}

declare class SohoTabsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTabsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTabsModule, never, [typeof SohoTabsComponent, typeof SohoTabListContainerComponent, typeof SohoTabListComponent, typeof SohoTabComponent, typeof SohoTabTitleComponent, typeof SohoTabCountComponent, typeof SohoTabSeparatorComponent, typeof SohoTabPanelContainerComponent, typeof SohoTabPanelComponent], [typeof SohoTabsComponent, typeof SohoTabListContainerComponent, typeof SohoTabListComponent, typeof SohoTabComponent, typeof SohoTabTitleComponent, typeof SohoTabCountComponent, typeof SohoTabSeparatorComponent, typeof SohoTabPanelContainerComponent, typeof SohoTabPanelComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTabsModule>;
}

declare class SohoTextAreaComponent extends BaseControlValueAccessor<string> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    ref: ChangeDetectorRef;
    private ngZone;
    private textStatic?;
    private options;
    /**
     * Local variables
     */
    private isDisabled?;
    private isReadOnly?;
    private runUpdatedOnCheck?;
    set disabled(value: boolean | undefined);
    get disabled(): boolean | undefined;
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    resizable?: boolean;
    set maxLength(maxLength: number | undefined);
    get maxLength(): number | undefined;
    set autoGrow(autoGrow: boolean | undefined);
    get autoGrow(): boolean | undefined;
    set autoGrowMaxHeight(autoGrowMaxHeight: number | undefined);
    get autoGrowMaxHeight(): number | undefined;
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    set characterCounter(characterCounter: boolean);
    set printable(printable: boolean);
    set charRemainingText(charRemainingText: string);
    set charMaxText(charMaxText: string);
    /**
     * Called when the textarea updates in some way
     */
    updated: EventEmitter<SohoTextAreaEvent>;
    /**
     * @todo Change to 'changed'.
     */
    change: EventEmitter<SohoTextAreaEvent[]>;
    private jQueryElement?;
    private textarea?;
    /**
     * Specific host listener for textarea.
     *
     * @param textarea the HTML element
     */
    oninput(event: SohoTextAreaEvent, textarea: HTMLTextAreaElement): void;
    constructor(element: ElementRef, ref: ChangeDetectorRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /**
     * Handle the control being changed.
     */
    onChange(event: any[]): void;
    /**
     * Override writeValue to allow the input to count correctly
     *
     * @param value - the new value
     */
    writeValue(value: any): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTextAreaComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTextAreaComponent, "textarea[soho-textarea]", never, { "disabled": { "alias": "disabled"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "maxLength": { "alias": "maxLength"; "required": false; }; "autoGrow": { "alias": "autoGrow"; "required": false; }; "autoGrowMaxHeight": { "alias": "autoGrowMaxHeight"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "characterCounter": { "alias": "characterCounter"; "required": false; }; "printable": { "alias": "printable"; "required": false; }; "charRemainingText": { "alias": "charRemainingText"; "required": false; }; "charMaxText": { "alias": "charMaxText"; "required": false; }; }, { "updated": "updated"; "change": "change"; }, never, ["*"], true, never>;
}

declare class SohoTextAreaModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTextAreaModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTextAreaModule, never, [typeof SohoTextAreaComponent], [typeof SohoTextAreaComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTextAreaModule>;
}

declare class SohoTimelineComponent implements AfterViewInit, OnDestroy {
    private element;
    /** Options. */
    private settings;
    get isTimeline(): boolean;
    private jQueryElement?;
    private timeline?;
    constructor(element: ElementRef);
    /** Setup */
    ngAfterViewInit(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    /** Update the timeline height */
    updated(settings?: SohoTimelineOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTimelineComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTimelineComponent, "[soho-timeline]", never, {}, {}, never, ["*"], true, never>;
}

declare class SohoTimelineModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTimelineModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTimelineModule, never, [typeof SohoTimelineComponent], [typeof SohoTimelineComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTimelineModule>;
}

declare class SohoTimePickerComponent extends BaseControlValueAccessor<any> implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    ref: ChangeDetectorRef;
    private runUpdatedOnCheck?;
    /**
     * Local variables
     */
    private jQueryElement?;
    private timepicker?;
    private isDisabled?;
    private isReadOnly?;
    private options?;
    /**
     * Indicates mode, either 'standard' or 'range'; default value is 'standard'
     */
    set mode(mode: SohoTimePickerMode);
    /**
     * Indicates the pattern for the time format.
     */
    set timeFormat(timeFormat: string);
    /**
     * An integer from 1 to 60; multiples of this value are displayed as options in the minutes dropdown;
     * default value is 5.
     */
    set minuteInterval(minuteInterval: number);
    /**
     * If a non-matching minutes value is entered, will round the minutes value to the nearest interval on the blur event;
     * default value is false;
     */
    set roundToInterval(roundToInterval: boolean);
    /**
     * The name of the locale to use for this instance. If not set, the current locale will be used.
     */
    set locale(locale: string);
    /**
     * The name of the language to use for this instance. If not set, the current locale will be used or the the passed locale will be used.
     */
    set language(language: string);
    /**
     * An integer from 1 to 60; multiples of this value are displayed as options in the seconds dropdown;
     * default value is 5.
     */
    set secondInterval(secondInterval: number);
    /**
     * If defined as a JQuery-wrapped element, will be used as the target element.
     */
    set parentElement(parentElement: JQuery);
    /**
     * If set to false, focus will not be returned to the calling element;
     * default value is true.
     */
    set returnFocus(returnFocus: boolean);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /**
     * Set the input to tabbable
     */
    set tabbable(tabbable: boolean);
    /**
     * Sets the control to be disabled or not.
     */
    set disabled(value: boolean | undefined);
    /**
     * @param beforeValidate before validate.
     */
    set beforeValidate(beforeValidate: any);
    /**
     * Public API
     */
    get disabled(): boolean | undefined;
    /**
     * Sets the control to readonly
     */
    set readonly(value: boolean | undefined);
    get readonly(): boolean | undefined;
    /**
     * Called when the datepicker value changes
     *
     * @todo remove override of native attribute.
     */
    change: EventEmitter<SohoTimePickerEvent>;
    setValue(time: string | undefined): void;
    /**
     * Bind attributes to the host input element
     */
    get isTimepicker(): boolean;
    /**
     * Creates an instance of SohoTimePickerComponent.
     *
     * @param element the element this component encapsulates.
     * @param ngZone the angular zone for this component.
     * @param ref reference to the change detector
     *
     */
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    /**
     * Handle the control being changed.
     */
    onChange(event: SohoTimePickerEvent): void;
    /**
     * Override writeValue to allow the time picker
     * element to be updated correctly.
     *
     * @param value - the new value
     */
    writeValue(value: any): void;
    /**
     * This function is called when the control status changes to or from "DISABLED".
     * Depending on the value, it will enable or disable the appropriate DOM element.
     */
    setDisabledState(isDisabled: boolean): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTimePickerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTimePickerComponent, "input[soho-timepicker]", never, { "mode": { "alias": "mode"; "required": false; }; "timeFormat": { "alias": "timeFormat"; "required": false; }; "minuteInterval": { "alias": "minuteInterval"; "required": false; }; "roundToInterval": { "alias": "roundToInterval"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "language": { "alias": "language"; "required": false; }; "secondInterval": { "alias": "secondInterval"; "required": false; }; "parentElement": { "alias": "parentElement"; "required": false; }; "returnFocus": { "alias": "returnFocus"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "tabbable": { "alias": "tabbable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "beforeValidate": { "alias": "beforeValidate"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "change": "change"; }, never, ["*"], true, never>;
}

declare class SohoTimePickerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTimePickerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTimePickerModule, never, [typeof SohoTimePickerComponent], [typeof SohoTimePickerComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTimePickerModule>;
}

declare class SohoToastModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToastModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoToastModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoToastModule>;
}

declare class SohoToastService {
    static TOP_LEFT: SohoToastPosition;
    static TOP_RIGHT: SohoToastPosition;
    static BOTTOM_LEFT: SohoToastPosition;
    static BOTTOM_RIGHT: SohoToastPosition;
    /**
     * Show a toast using the specified options.
     */
    show(options: SohoToastOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToastService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SohoToastService>;
}

/**
 * needed in case you are using an *ngIf to display and remove the toolbar search field.
 * Otherwise sohoxi will create a wrapper and angular will not know how to handle the
 * element structure change.
 */
declare class SohoToolbarSearchFieldWrapperComponent {
    get isSearchfieldWrapper(): boolean;
    get isToolbarSearchfieldWrapper(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarSearchFieldWrapperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarSearchFieldWrapperComponent, "span[soho-toolbar-searchfield-wrapper]", never, {}, {}, never, ["*"], true, never>;
}
declare class SohoToolbarSearchFieldComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private changeDetector;
    private element;
    private ngZone;
    /** Options. */
    options: SohoToolbarSearchFieldOptions;
    /** Adds an X button for clearing the search value. */
    set clearable(value: boolean);
    /** Where it's collapsible or not */
    set collapsible(value: boolean);
    set collapsibleOnMobile(value: boolean);
    /** AutoComplete : Source Function/Data/Url/Array */
    set source(value: SohoAutoCompleteSource);
    /** Template that can be passed */
    set template(value: string);
    selected: EventEmitter<Object[]>;
    cleared: EventEmitter<Object[]>;
    get isSearchField(): boolean;
    /**
     * Local variables
     */
    private jQueryElement?;
    private toolbarsearchfield?;
    private searchFieldChanged;
    constructor(changeDetector: ChangeDetectorRef, element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    clear(): void;
    private markForRefresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarSearchFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarSearchFieldComponent, "input[soho-toolbar-searchfield]", never, { "options": { "alias": "options"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "collapsibleOnMobile": { "alias": "collapsibleOnMobile"; "required": false; }; "source": { "alias": "source"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "selected": "selected"; "cleared": "cleared"; }, never, ["*"], true, never>;
}
/**
 * soho toolbar more button
 */
declare class SohoToolbarMoreButtonComponent {
    get isMoreButton(): boolean;
    isPageChanger: boolean;
    isDisabled: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarMoreButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarMoreButtonComponent, "soho-toolbar-more-button", never, { "isPageChanger": { "alias": "isPageChanger"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * soho toolbar page title.
 */
declare class SohoPageTitleComponent {
    get isPageTitle(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoPageTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoPageTitleComponent, "span[soho-page-title]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * soho section title.
 */
declare class SohoSectionTitleComponent {
    get isSectionTitle(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSectionTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSectionTitleComponent, "span[soho-section-title]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * soho selection count.
 */
declare class SohoSelectionCountComponent {
    get isTitle(): boolean;
    get isSelectionCount(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoSelectionCountComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoSelectionCountComponent, "div[soho-selection-count]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Soho toolbar Navigation button
 */
declare class SohoToolbarNavButtonComponent {
    get isIconButton(): boolean;
    get isAppMenuTrigger(): boolean;
    get typeAttr(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarNavButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarNavButtonComponent, "button[soho-nav-button]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Soho toolbar title
 */
declare class SohoToolbarTitleComponent {
    get isTitle(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarTitleComponent, "soho-toolbar-title", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Soho toolbar buttonset
 */
declare class SohoToolbarButtonSetComponent {
    get isButtonSet(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarButtonSetComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarButtonSetComponent, "soho-toolbar-button-set", never, {}, {}, never, ["*"], true, never>;
}
/**
 * The main soho toolbar component
 */
declare class SohoToolbarComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private changeDetector;
    private element;
    private ngZone;
    get isToolbar(): boolean;
    get showMoreButton(): boolean | undefined;
    get isBlock(): "block" | null;
    /**
     * Whether to display the overflow more-button or not regardless of
     * overflow content.
     */
    noActionsButton: boolean;
    /**
     * Set the has more button component option, this is used
     * to define if the more button is expected to exist in the toolbar logic.
     */
    set hasMoreButton(value: boolean);
    /**
     * Set the expected max visible buttons before overflow is forced.
     */
    set maxVisibleButtons(value: number);
    /**
     * Set the rightAligned hint. This is for toolbars with no title that should be forced to right align.
     */
    set rightAligned(value: boolean);
    /**
     * @deprecated Use the rightAligned option.
     */
    set rightAlign(value: boolean);
    /**
     * If true, uses Javascript to size the Title and Buttonset elements in a way that shows as much of the Title area as possible.
     */
    set resizeContainers(value: boolean);
    /**
     * If "resizeContainers" is true, setting this to true will try to display as many buttons as possible while resizing the toolbar.
     * Setting to false attempts to show the entire title instead.
     */
    set favorButtonset(value: boolean);
    /**
     * Allows a moreMenuSettings object to be propagated down into the Toolbar.
     * the jQuery Toolbar component handles passing these settings into the More Actions
     * menu's jQuery Popupmenu.
     */
    set moreMenuSettings(value: SohoPopupMenuOptions);
    /** Add extra attributes like id's to the component **/
    set attributes(value: Array<Object> | Object);
    /**
     * The beforeactivate event is fired whenever a toolbar is activated giving the event handler a chance
     * to "veto" the tab selection change.
     */
    beforeActivated: EventEmitter<SohoToolbarEvent>;
    /**
     * The activated event is if the beforeActivate succeeds.
     */
    activated: EventEmitter<SohoToolbarEvent>;
    /**
     * The afteractivate event is fired after the toolbar has been activated.
     */
    afterActivated: EventEmitter<SohoToolbarEvent>;
    /**
     * The selected event is fired when a toolbar button has been clicked.
     */
    selected: EventEmitter<SohoToolbarSelectedEvent>;
    menuItemMouseOver: EventEmitter<HTMLButtonElement>;
    private options;
    private jQueryElement?;
    private toolbar?;
    private toolbarChanged?;
    constructor(changeDetector: ChangeDetectorRef, element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    updated(settings?: any): void;
    handleResize(): void;
    private markForRefresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarComponent, "soho-toolbar, div[soho-toolbar]", never, { "noActionsButton": { "alias": "noActionsButton"; "required": false; }; "hasMoreButton": { "alias": "hasMoreButton"; "required": false; }; "maxVisibleButtons": { "alias": "maxVisibleButtons"; "required": false; }; "rightAligned": { "alias": "rightAligned"; "required": false; }; "rightAlign": { "alias": "rightAlign"; "required": false; }; "resizeContainers": { "alias": "resizeContainers"; "required": false; }; "favorButtonset": { "alias": "favorButtonset"; "required": false; }; "moreMenuSettings": { "alias": "moreMenuSettings"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "beforeActivated": "beforeActivated"; "activated": "activated"; "afterActivated": "afterActivated"; "selected": "selected"; "menuItemMouseOver": "menuItemMouseOver"; }, never, ["soho-toolbar-title", "soho-toolbar-button-set", "soho-toolbar-more-button"], true, never>;
}

declare class SohoToolbarModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoToolbarModule, never, [typeof SohoToolbarComponent, typeof SohoToolbarButtonSetComponent, typeof SohoToolbarTitleComponent, typeof SohoToolbarNavButtonComponent, typeof SohoSectionTitleComponent, typeof SohoSelectionCountComponent, typeof SohoPageTitleComponent, typeof SohoToolbarMoreButtonComponent, typeof SohoToolbarSearchFieldComponent, typeof SohoToolbarSearchFieldWrapperComponent], [typeof SohoToolbarComponent, typeof SohoToolbarButtonSetComponent, typeof SohoToolbarTitleComponent, typeof SohoToolbarNavButtonComponent, typeof SohoSectionTitleComponent, typeof SohoSelectionCountComponent, typeof SohoPageTitleComponent, typeof SohoToolbarMoreButtonComponent, typeof SohoToolbarSearchFieldComponent, typeof SohoToolbarSearchFieldWrapperComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoToolbarModule>;
}

declare class SohoToolbarFlexSearchFieldComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private changeDetector;
    private element;
    private ngZone;
    /**
     * Options, overwriting any existing options already set on the component, and hence combining
     * this Input with the othera is not recommended.
     *
     * (Note: could change this to use {...this._options,...value})
     */
    options: SohoToolbarFlexSearchFieldOptions;
    /** Adds an X button for clearing the search value. */
    set clearable(value: boolean);
    /** Where it's collapsible or not */
    set collapsible(value: boolean);
    set collapsibleOnMobile(value: boolean);
    set filterMode(value: SohoAutoCompleteFilterMode);
    /** AutoComplete : Source Function/Data/Url/Array */
    set source(value: SohoAutoCompleteSource);
    /** Template that can be passed */
    set template(value: string);
    selected: EventEmitter<Object[]>;
    cleared: EventEmitter<Object[]>;
    /**
     * @todo replace override of native element
     */
    change: EventEmitter<Object[]>;
    get isSearchField(): boolean;
    /**
     * Local variables
     */
    private jQueryElement?;
    private toolbarFlexSearchField?;
    private searchFieldChanged;
    constructor(changeDetector: ChangeDetectorRef, element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    clear(): void;
    get searchField(): SohoToolbarFlexSearchFieldStatic | undefined;
    private markForRefresh;
    updated(settings: SohoToolbarFlexSearchFieldOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexSearchFieldComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexSearchFieldComponent, "input[soho-toolbar-flex-searchfield]", never, { "options": { "alias": "options"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "collapsibleOnMobile": { "alias": "collapsibleOnMobile"; "required": false; }; "filterMode": { "alias": "filterMode"; "required": false; }; "source": { "alias": "source"; "required": false; }; "template": { "alias": "template"; "required": false; }; }, { "selected": "selected"; "cleared": "cleared"; "change": "change"; }, never, ["*"], true, never>;
}
/**
 * soho toolbar flex more button
 */
declare class SohoToolbarFlexMoreButtonComponent {
    isMoreButton: boolean;
    isToolbarSection: boolean;
    isPageChanger: boolean;
    isDisabled: boolean;
    moreButtonId?: string;
    /** @deprecated doesn't seem to be used **/
    ajaxBeforeFunction?: Function;
    /** @deprecated doesn't seem to be used **/
    menuId?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexMoreButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexMoreButtonComponent, "soho-toolbar-flex-more-button", never, { "isPageChanger": { "alias": "isPageChanger"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "moreButtonId": { "alias": "moreButtonId"; "required": false; }; "ajaxBeforeFunction": { "alias": "ajaxBeforeFunction"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * soho toolbar flex page title.
 */
declare class SohoToolbarFlexPageTitleComponent {
    isPageTitle: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexPageTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexPageTitleComponent, "[soho-toolbar-flex-page-title]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * soho toolbar flex section title.
 */
declare class SohoToolbarFlexSectionTitleComponent {
    isSectionTitle: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexSectionTitleComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexSectionTitleComponent, "[soho-toolbar-flex-section-title]", never, {}, {}, never, ["*"], true, never>;
}
/**
 * Generic soho toolbar flex section
 */
declare class SohoToolbarFlexSectionComponent {
    isToolbarSection: boolean;
    isTitleFavor: boolean;
    isTitle: boolean;
    isButtonSet: boolean;
    isSearch: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexSectionComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexSectionComponent, "soho-toolbar-flex-section", never, { "isTitleFavor": { "alias": "isTitleFavor"; "required": false; }; "isTitle": { "alias": "isTitle"; "required": false; }; "isButtonSet": { "alias": "isButtonSet"; "required": false; }; "isSearch": { "alias": "isSearch"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * Soho toolbar Navigation button
 */
declare class SohoToolbarFlexNavButtonComponent implements AfterViewInit {
    private element;
    private ngZone;
    isIconButton: boolean;
    isAppMenuTrigger: boolean;
    typeAttr: string;
    /** Reference to the Soho control api. */
    private button?;
    private _buttonOptions;
    /** Reference to the jQuery control. */
    private jQueryElement?;
    constructor(element: ElementRef, ngZone: NgZone);
    set buttonOptions(buttonOptions: SohoButtonOptions);
    get buttonOptions(): SohoButtonOptions;
    ngAfterViewInit(): void;
    updated(settings?: SohoButtonOptions): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexNavButtonComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexNavButtonComponent, "button[soho-toolbar-flex-nav-button]", never, { "buttonOptions": { "alias": "buttonOptions"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/**
 * The soho toolbar flex component
 */
declare class SohoToolbarFlexComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private changeDetector;
    private element;
    private ngZone;
    isToolbar: boolean;
    /**
     * Allows a moreMenuSettings object to be propagated down into the Toolbar Flex.
     * the jQuery Toolbar Flex component handles passing these settings into the More Actions
     * menu's jQuery Popupmenu.
     */
    set moreMenuBeforeOpenFunction(beforeOpen: AjaxBeforeMoreMenuOpenFunction);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /**
     * The selected event is fired when a toolbar button has been clicked.
     */
    selected: EventEmitter<SohoToolbarFlexSelectedEvent>;
    private _options;
    private jQueryElement?;
    private toolbarFlex?;
    private toolbarFlexChanged?;
    constructor(changeDetector: ChangeDetectorRef, element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    ngOnDestroy(): void;
    updated(settings?: SohoToolbarFlexOptions): void;
    /**
     * The buttonset API for the modal dialog.
     *
     * @returns the buttonset API for the modal dialog, if initialised.
     */
    get buttonsetAPIs(): Array<SohoButtonsetStatic> | undefined;
    /**
     * The buttonset API for the modal dialog.
     *
     * @returns the buttonset API for the modal dialog, if initialised.
     */
    get buttonsets(): Array<HTMLElement> | undefined;
    get options(): SohoToolbarFlexOptions;
    private markForRefresh;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoToolbarFlexComponent, "soho-toolbar-flex, div[soho-toolbar-flex]", never, { "moreMenuBeforeOpenFunction": { "alias": "moreMenuBeforeOpenFunction"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "selected": "selected"; }, never, ["*"], true, never>;
}

declare class SohoToolbarFlexModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoToolbarFlexModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoToolbarFlexModule, never, [typeof SohoToolbarFlexComponent, typeof SohoToolbarFlexNavButtonComponent, typeof SohoToolbarFlexSectionTitleComponent, typeof SohoToolbarFlexPageTitleComponent, typeof SohoToolbarFlexMoreButtonComponent, typeof SohoToolbarFlexSectionComponent, typeof SohoToolbarFlexSearchFieldComponent], [typeof SohoToolbarFlexComponent, typeof SohoToolbarFlexNavButtonComponent, typeof SohoToolbarFlexSectionTitleComponent, typeof SohoToolbarFlexPageTitleComponent, typeof SohoToolbarFlexMoreButtonComponent, typeof SohoToolbarFlexSectionComponent, typeof SohoToolbarFlexSearchFieldComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoToolbarFlexModule>;
}

declare class SohoTooltipDirective implements AfterViewInit, OnDestroy, OnChanges {
    private element;
    private options;
    /**
     * @param content the content of the tooltip
     */
    set content(content: string);
    /**
     * @param offset offset
     */
    set offset(offset: number);
    /**
     * @param placement the orientation of the tooltip based on the source component.
     */
    set placement(placement: SohoTooltipOffset);
    set trigger(trigger: string);
    /**
     * @param tooltipTitle the title of the tooltip.
     */
    set title(title: string);
    /**
     * @param beforeShow before show.
     */
    set beforeShow(beforeShow: any);
    /**
     * @param popover is this a popover?
     */
    set popover(popover: boolean);
    /**
     * @param closebutton display the close button?
     */
    set closebutton(closebutton: boolean);
    /**
     * @param isError is this an error tooltip.
     */
    set isError(isError: boolean);
    /**
     * @param isErrorColor use the error color.
     */
    set isErrorColor(isErrorColor: boolean);
    /**
     * @param tooltipElement tooptip element
     */
    set tooltipElement(tooltipElement: any);
    /**
     * @param keepOpen keep the tooltip open?
     */
    set keepOpen(keepOpen: boolean);
    /**
     * @param extraClass additional classes
     */
    set extraClass(extraClass: string);
    /**
     * @param appendTo additional classes
     */
    set appendTo(appendTo: string);
    /**
     * @param maxWidth the maximum width of the tooltip in pixels.
     */
    set maxWidth(maxWidth: number);
    /**
     * If the object with the tooltip is tabbed to, will also show the tooltip.
     */
    set showOnKeyboardFocus(showOnKeyboardFocus: boolean);
    /**
     * Call back for hiding.
     */
    set onHidden(onHidden: Function);
    /**
     * Placement options pass through
     */
    set placementOpt(placementOpt: object);
    /**
     * Init the content in the tooltip.
     */
    set initializeContent(initializeContent: boolean);
    /**
     * If set this color will be used on the header (if a popover).
     */
    set headerClass(headerClass: string);
    /**
     * The delay before showing the tooltip
     */
    set delay(delay: number);
    /**
     * The if true (default) the popup is added to the body.
     */
    set attachToBody(attachToBody: boolean);
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object);
    /**
     * Called when the tooltip value changes
     */
    changeEvent: EventEmitter<SohoTooltipEvent>;
    /**
     * Called when the tooltip updates in some way
     */
    updateEvent: EventEmitter<SohoTooltipEvent>;
    private jQueryElement?;
    private tooltip?;
    constructor(element: ElementRef);
    ngAfterViewInit(): void;
    private createControl;
    /**
     * Shows the tooltip.
     */
    show(): void;
    /**
     * Hides the tooltip.
     */
    hide(force?: boolean): void;
    ngOnDestroy(): void;
    ngOnChanges(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTooltipDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoTooltipDirective, "[soho-tooltip]", never, { "content": { "alias": "content"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "placement": { "alias": "placement"; "required": false; }; "trigger": { "alias": "trigger"; "required": false; }; "title": { "alias": "title"; "required": false; }; "beforeShow": { "alias": "beforeShow"; "required": false; }; "popover": { "alias": "popover"; "required": false; }; "closebutton": { "alias": "closebutton"; "required": false; }; "isError": { "alias": "isError"; "required": false; }; "isErrorColor": { "alias": "isErrorColor"; "required": false; }; "tooltipElement": { "alias": "tooltipElement"; "required": false; }; "keepOpen": { "alias": "keepOpen"; "required": false; }; "extraClass": { "alias": "extraClass"; "required": false; }; "appendTo": { "alias": "appendTo"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "showOnKeyboardFocus": { "alias": "showOnKeyboardFocus"; "required": false; }; "onHidden": { "alias": "onHidden"; "required": false; }; "placementOpt": { "alias": "placementOpt"; "required": false; }; "initializeContent": { "alias": "initializeContent"; "required": false; }; "headerClass": { "alias": "headerClass"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "attachToBody": { "alias": "attachToBody"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "changeEvent": "changeEvent"; "updateEvent": "updateEvent"; }, never, never, true, never>;
}

declare class SohoTooltipModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTooltipModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTooltipModule, never, [typeof SohoTooltipDirective], [typeof SohoTooltipDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTooltipModule>;
}

declare class SohoTrackDirtyDirective implements AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    get trackDirtyAttr(): boolean;
    /**
     * Called when element value is different from original value
     */
    dirty: EventEmitter<SohoTrackDirtyEvent>;
    /**
     * Called when element value is same as original value
     */
    pristine: EventEmitter<SohoTrackDirtyEvent>;
    /**
     * Called when the element has its original value reset to the current value
     */
    afterResetDirty: EventEmitter<SohoTrackDirtyEvent>;
    /**
     * Local variables
     */
    private jQueryElement?;
    private trackDirty?;
    constructor(element: ElementRef, ngZone: NgZone);
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    changeDirty(): void;
    resetDirty(): void;
    updated(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTrackDirtyDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<SohoTrackDirtyDirective, "[soho-trackdirty]", ["soho-trackdirty"], {}, { "dirty": "dirty"; "pristine": "pristine"; "afterResetDirty": "afterResetDirty"; }, never, never, true, never>;
}

declare class SohoTrackDirtyModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTrackDirtyModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTrackDirtyModule, never, [typeof SohoTrackDirtyDirective], [typeof SohoTrackDirtyDirective]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTrackDirtyModule>;
}

/**
 * Soho Dynamic Tree Service contract.
 *
 * Useful where lazily loading of the tree is required, can also make
 * controlling the tree easier.
 */
declare abstract class SohoTreeService {
    /**
     * Returns the root tree node, without any
     * children.
     *
     * This default service return an single root node.
     *
     * @todo allow this to be parameterised, such that the caller can control initial depth, recursion, etc ...
     */
    abstract getRootTreeNodes(): Observable<SohoTreeNode[]>;
    /**
     * Given an existing TreeNode, this method returns a list
     * of child TreeNodes, as a observable.  Thus allowing for the
     * tree to lazy load from any in-memory or external source.
     *
     */
    abstract getTreeNodes(node: SohoTreeNode): Observable<SohoTreeNode[]>;
}

/**
 *  Valid list of tree types.
 */
type SohoTreeType = 'auto' | 'content-only';
/**
 * Angular Wrapper for the Soho Tree Component.
 *
 * This component searches for an unordered list (ul) with the attribute
 * 'soho-tree' in the parent's DOM tree, initialising those found with
 * the SoHo tree control.
 *
 * The data is provided either by the content (li elements), a dataset
 * input or an implementation of the TreeService interface, by specifying
 * an implementation on the hosting component, e.g.
 *
 * providers: [ provide: TreeService, useClass: TreeDemoService} ]
 *
 * @todo Content based version does not work due to lack of TreeNode.
 * @todo Complete interface definition
 */
declare class SohoTreeComponent implements AfterViewInit, OnInit, OnDestroy {
    private elementRef;
    private treeService;
    static AUTO: SohoTreeType;
    static CONTENT_ONLY: SohoTreeType;
    set dataset(dataset: SohoTreeNode[] | undefined);
    get dataset(): SohoTreeNode[] | undefined;
    /** Defines the source type of the tree. */
    set sohoTree(treeType: SohoTreeType | '');
    /** Is the tree selectable? */
    set selectable(selectable: SohoTreeSelectable | undefined);
    get selectable(): SohoTreeSelectable | undefined;
    /** Show/hide selection checkboxe */
    set hideCheckboxes(hideCheckboxes: boolean | undefined);
    set menuId(menuId: string | undefined);
    /** Set the source field, when not using a service or pre-defined data. */
    set source(value: SohoTreeSourceFunction);
    /** Show icon on node opened */
    set folderIconOpen(folderIconOpen: string);
    /** Show icon on node closed */
    set folderIconClosed(folderIconClosed: string);
    /**
     * This event is fired when a node is expanded, the SohoTreeNode
     * expanded is passed in the argument passed to the handler.
     */
    expanded: EventEmitter<SohoTreeEvent>;
    /**
     * This event is fired when a node is collapsed, the SohoTreeNode
     * collapsed is passed in the argument passed to the handler.
     */
    collapsed: EventEmitter<SohoTreeEvent>;
    /**
     * This event is fired when a node is selected, the SohoTreeNode
     * selected is passed in the argument passed to the handler.
     * */
    selected: EventEmitter<SohoTreeEvent>;
    /**
     * This event is fired when right clicking a node.
     * */
    contextmenu: EventEmitter<SohoTreeEvent>;
    /**
     * This event is fired when a node is unselected, the SohoTreeNode
     * unselected is passed in the argument passed to the handler.
     * */
    unselected: EventEmitter<SohoTreeEvent>;
    sortstart: EventEmitter<SohoTreeEvent>;
    sortend: EventEmitter<SohoTreeEvent>;
    /**
     * This event is fired when context menu is selected, the SohoTreeNode
     * selected is passed in the argument passed to the handler.
     * */
    menuselect: EventEmitter<SohoTreeEvent>;
    /**
     * This event is fired on context menu opening, the SohoTreeNode
     * selected is passed in the argument passed to the handler.
     * */
    menuopen: EventEmitter<SohoTreeEvent>;
    dblclick: EventEmitter<SohoTreeEvent>;
    isDisabled: boolean;
    treeClass: boolean;
    treeRole: string;
    /** Reference to the jQuery control. */
    private jQueryElement?;
    /** Reference to the SoHo tree control api. */
    private tree?;
    /** The tree's type. */
    private treeType?;
    /** An internal options object that gets updated by using the component's Inputs(). */
    options: SohoTreeOptions;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching this directive.
     * @param treeService - service for obtaining data (optional)
     */
    constructor(elementRef: ElementRef, treeService: SohoTreeService);
    /**
     * Resets the data display to the default provided by the service,
     * that is by calling getRootNodes.
     *
     * The alternative is to set the dataset property, which
     * has the same affect but allows the client to specify
     * the nodes.
     *
     * This method is only applicable when the service is defined,
     * but will not fail if one is not set.
     */
    reset(): void;
    /** Enable the tree */
    enable(): void;
    /** Disables the tree from reacting to events. */
    disable(): void;
    setFocus(node: SohoTreeNode): void;
    disableNode(node: SohoTreeNode): void;
    enableNode(node: SohoTreeNode): void;
    /**
     * Updates the note with the information in the given SohoTreeNode.
     *
     * @parm node the tree node; must not be null.
     */
    updateNode(node: SohoTreeNode): void;
    /**
     * Expands all the loaded tree nodes.
     *
     * Note: this does not load additional nodes.
     */
    expandAll(): void;
    /**
     * Collapse all the tree nodes.
     */
    collapseAll(): void;
    /**
     * Remove the given node.
     */
    removeNode(node: SohoTreeNode): void;
    /**
     * Preserves all nodes' enablement states in the Tree component
     */
    preserveEnablementState(): SohoTreeNode[] | undefined;
    /**
     * Restores all nodes' original enablement states in the Tree component
     */
    restoreEnablementState(): void;
    /**
     * Set the selected note based in the id of the node.  If the node
     * does not exist an exception is thrown.
     */
    selectNode(id: string, focus?: boolean): void;
    /**
     * Set the selected note based in the id of the node.  If the node
     * does not exist an exception is thrown.
     */
    unSelectedNode(id: string, focus?: boolean): void;
    /**
     * Returns a list of selected tree nodes, or an
     * empty array if the tree has not been initialised
     * yet.
     */
    getSelectedNodes(): SohoTreeNode[];
    /**
     * Adds a node to the tree.
     */
    addNode(treeNode: SohoTreeNode, location?: any, isBeforeOrAfter?: string): void;
    /**
     * Find the tree node for the given identifier (id).
     */
    findById(id: string): SohoTreeNode;
    /**
     * Toggles open/closed state of the given tree node.
     */
    toggleNode(node: SohoTreeNode): void;
    /**
     * Handle a request to load the children of the specified node.
     *
     * event - the tree event used to determine which node to load
     * response - function used to return the children
     */
    private onDataRequest;
    ngOnInit(): void;
    ngAfterViewInit(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTreeComponent, [null, { optional: true; }]>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTreeComponent, "ul[soho-tree]", never, { "dataset": { "alias": "dataset"; "required": false; }; "sohoTree": { "alias": "soho-tree"; "required": false; }; "selectable": { "alias": "selectable"; "required": false; }; "hideCheckboxes": { "alias": "hideCheckboxes"; "required": false; }; "menuId": { "alias": "menuId"; "required": false; }; "source": { "alias": "source"; "required": false; }; "folderIconOpen": { "alias": "folderIconOpen"; "required": false; }; "folderIconClosed": { "alias": "folderIconClosed"; "required": false; }; }, { "expanded": "expanded"; "collapsed": "collapsed"; "selected": "selected"; "contextmenu": "contextmenu"; "unselected": "unselected"; "sortstart": "sortstart"; "sortend": "sortend"; "menuselect": "menuselect"; "menuopen": "menuopen"; "dblclick": "dblclick"; }, never, ["*"], true, never>;
}

declare class SohoTreeModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTreeModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTreeModule, never, [typeof SohoTreeComponent], [typeof SohoTreeComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTreeModule>;
}

declare class SohoTreemapComponent implements AfterViewInit, AfterViewChecked, OnDestroy {
    private element;
    private ngZone;
    /** Options. */
    private options;
    get isTreemap(): boolean;
    /** Defines the data to use, must be specified for this component. */
    set dataset(dataset: Object);
    /** If false, the component will not resize when resizing the page. */
    set redrawOnResize(value: boolean);
    /** The margins of the SVG, which you may want to adjust depending on text location. */
    set margin(value: Object[]);
    /** An array of colors used in sequence from front to end of the array. */
    set colors(value: Array<any>);
    /** If false then the percentage wont be shown in the blocks. */
    set showLabel(value: boolean);
    /** The d3 formatter function for the value label. */
    set labelFormatter(value: string);
    /** If true then the first name will be used for the title area. */
    set showTitle(value: boolean);
    /** An empty message will be displayed when there is no chart data. */
    set emptyMessage(value: SohoEmptyMessageOptions);
    /** Add extra attributes like id's to the component **/
    set attributes(value: Array<Object> | Object);
    /** Events */
    rendered: EventEmitter<Object>;
    private jQueryElement?;
    private treemap?;
    private updateRequired;
    constructor(element: ElementRef, ngZone: NgZone);
    /** Setup */
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    /** Tear Down */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTreemapComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoTreemapComponent, "[soho-treemap]", never, { "dataset": { "alias": "dataset"; "required": false; }; "redrawOnResize": { "alias": "redrawOnResize"; "required": false; }; "margin": { "alias": "margin"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "showLabel": { "alias": "showLabel"; "required": false; }; "labelFormatter": { "alias": "labelFormatter"; "required": false; }; "showTitle": { "alias": "showTitle"; "required": false; }; "emptyMessage": { "alias": "emptyMessage"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; }, { "rendered": "rendered"; }, never, ["*"], true, never>;
}

declare class SohoTreemapModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoTreemapModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoTreemapModule, never, [typeof SohoTreemapComponent], [typeof SohoTreemapComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoTreemapModule>;
}

/**
 * Angular wrapper for the soho wizard tick.
 *
 * This wraps anchor tags annotated with the `soho-wizard-tick`.
 */
declare class SohoWizardTickComponent implements AfterViewInit {
    private elementRef;
    /**
     * Ensure any classes are set correctly.
     */
    isWizardTick: boolean;
    /**
     * For the `href` use the id.
     */
    get hrefAttr(): string | null;
    /**
     * A shorter label.
     */
    shortLabel?: string;
    /**
     * The id, used to link back to the pages.
     */
    tickId: string;
    /**
     *
     */
    current: boolean;
    /**
     * Disabled the tick.
     */
    disabled: boolean;
    /**
     * JQuery Element.
     */
    jQueryElement?: JQuery;
    /**
     * Disable the click handler.
     */
    onClick(event: Event): void;
    isCurrentTick(): boolean;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching this component.
     */
    constructor(elementRef: ElementRef);
    ngAfterViewInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardTickComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWizardTickComponent, "a[soho-wizard-tick]", never, { "shortLabel": { "alias": "shortLabel"; "required": false; }; "tickId": { "alias": "tickId"; "required": false; }; "current": { "alias": "current"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}

/**
 * Angular wrapper for the soho wizard header.
 *
 * Looks for a `div` annotated with `soho-wizard-header`, this
 * simply add a wrapper around the wizard ticks.
 */
declare class SohoWizardHeaderComponent {
    /**
     * List of ticks in the control.
     */
    steps?: QueryList<SohoWizardTickComponent>;
    isWizardHeader: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardHeaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWizardHeaderComponent, "div[soho-wizard-header]", never, {}, {}, ["steps"], ["*"], true, never>;
}

/**
 * Angular wrapper for the soho wizard page.
 */
declare class SohoWizardPageComponent implements AfterViewInit {
    private el;
    jQueryElement: JQuery;
    isWizardPage: boolean;
    /**
     * Is this wizard page hidden? Return true by default to avoid
     * displaying all the pages for a moment.  The wizard will
     * ensure only a single page is displayed.
     *
     *
     */
    hidden: boolean;
    /** This id of the associated tick. */
    tickId: string;
    /**
     * Event fired when the page is activated.
     */
    activated: EventEmitter<SohoWizardEvent>;
    /**
     * Constructor.
     *
     * @param el owning DOM element
     *
     */
    constructor(el: ElementRef);
    ngAfterViewInit(): void;
    /**
     * Fire the activated event, using the given SohoWizardEvent.
     *
     * I'd have rather done this with an event, but we end up
     * with a circular dependency.
     *
     * @param e - the soho wizard event.
     *
     */
    fireActivated(e: SohoWizardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardPageComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWizardPageComponent, "div[soho-wizard-page]", never, { "tickId": { "alias": "tickId"; "required": false; }; }, { "activated": "activated"; }, never, ["*"], true, never>;
}

/**
 * Angular wrapper for the soho wizard pagesß.
 */
declare class SohoWizardPagesComponent {
    pages: QueryList<SohoWizardPageComponent>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardPagesComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWizardPagesComponent, "div[soho-wizard-pages]", never, {}, {}, ["pages"], ["*"], true, never>;
}

/**
 * Angular Wrapper for the Soho Wizard Component.
 *
 * This component searches for a div with the attribute
 * 'soho-wizard' in the DOM, initialising those found with
 * the SoHo Wizard control.
 *
 * TODO:
 * =====
 *
 * - handling of ticks / tick model (based on underlying widget)
 * - model driven
 * - support Builder Panel style (with title?)
 * - support for "modal style" buttons.
 * - extract state machine
 */
declare class SohoWizardComponent implements AfterViewInit, AfterContentInit, OnDestroy {
    private elementRef;
    /**
     * Reference to the underlying container for the pages.
     *
     *
     *
     */
    pagesContainer?: SohoWizardPagesComponent;
    /**
     * Reference to the header, container for the ticks.
     *
     *
     *
     */
    header?: SohoWizardHeaderComponent;
    /**
     * Ticks for the settings - this does not really work yet (i think).
     */
    set ticks(ticks: SohoWizardTick[]);
    get ticks(): SohoWizardTick[];
    /** Id of the current tick. */
    set currentTickId(tickId: string);
    get currentTickId(): string;
    /**
     * Provides a `beforeActivate` vetoable handler, which
     * allows the caller to prevent activation of a link.
     *
     * @todo needs linking with any buttons!
     */
    private beforeActivate?;
    /**
     * This event is fired when a tick is activated.
     */
    activated: EventEmitter<SohoWizardEvent>;
    /**
     * This event is fired after a tick is activated.
     */
    afteractivated: EventEmitter<SohoWizardEvent>;
    isWizardClass: boolean;
    /** Reference to the jQuery control. */
    private jQueryElement?;
    /** Reference to the SoHo wizard control api. */
    private wizard?;
    /** An internal options object that gets updated by using the component's Inputs(). */
    private _options;
    /**
     * Ordered list of steps.
     *
     *
     *
     *
     */
    private _steps?;
    /**
     * Has the wizard finished.
     */
    private finished;
    /**
     * Constructor.
     *
     * @param elementRef - the element matching this component.
     */
    constructor(elementRef: ElementRef);
    /**
     * Returns the currently selected page.
     */
    get currentPage(): SohoWizardPageComponent | undefined;
    /**
     * Moves to the first state if possible.
     */
    first(): void;
    /**
     * Attempts to move to the next step, if allowed.
     *
     *
     */
    next(): void;
    /**
     * Attempts to move to the previous step, if allowed.
     *
     *
     */
    previous(): void;
    /**
     * Attempts to move to the last step, if allowed.
     *
     *
     */
    last(): void;
    /**
     * Attempts to move to the last step, and finish the wizard.
     *
     *
     */
    finish(): void;
    /**
     * Is there another step after the current step?
     *
     * @return  true if there is another step; otherwise false.
     *
     */
    hasNext(): boolean;
    /**
     * Is there previous step.
     */
    hasPrevious(): boolean;
    /**
     * Returns true if the process has finished,
     * otherwise false.
     */
    hasFinished(): boolean;
    /**
     * Resets the state machine, moving to the first page
     * and clearing finished flag.
     */
    reset(): void;
    ngAfterViewInit(): void;
    ngAfterContentInit(): void;
    /**
     * Handle component destruction by clearing down the SoHo
     * wizard component.
     *
     *
     */
    ngOnDestroy(): void;
    private onActivated;
    private onBeforeActivate;
    private stepCount;
    private steps;
    private stepAt;
    private currentIndex;
    private currentStep;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWizardComponent, "div[soho-wizard]", never, { "ticks": { "alias": "ticks"; "required": false; }; "currentTickId": { "alias": "currentTickId"; "required": false; }; "beforeActivate": { "alias": "beforeActivate"; "required": false; }; }, { "activated": "activated"; "afteractivated": "afteractivated"; }, ["pagesContainer", "header"], ["*"], true, never>;
}

/**
 * Angular wrapper for the soho wizard buttonbar.
 *
 * Looks for a `div` annotated with `soho-wizard-buttonbar`, this
 * simply adds a component used to handle the button selection.
 */
declare class SohoWizardButtonbarComponent {
    private wizard;
    private changeDetectorRef;
    buttons: SohoWizardButtonBarButton[];
    isButtonBar: boolean;
    constructor(wizard: SohoWizardComponent, changeDetectorRef: ChangeDetectorRef);
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardButtonbarComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWizardButtonbarComponent, "div[soho-wizard-buttonbar]", never, { "buttons": { "alias": "buttons"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class SohoWizardModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWizardModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoWizardModule, never, [typeof SohoWizardComponent, typeof SohoWizardTickComponent, typeof SohoWizardHeaderComponent, typeof SohoWizardPagesComponent, typeof SohoWizardPageComponent, typeof SohoWizardButtonbarComponent], [typeof SohoWizardComponent, typeof SohoWizardTickComponent, typeof SohoWizardHeaderComponent, typeof SohoWizardPagesComponent, typeof SohoWizardPageComponent, typeof SohoWizardButtonbarComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoWizardModule>;
}

/********************************************************************
 * Weekview component
 *******************************************************************/
declare class SohoWeekViewComponent implements AfterViewChecked, AfterViewInit, OnDestroy {
    private element;
    private ngZone;
    ref: ChangeDetectorRef;
    isWeekView: boolean;
    set weekViewOptions(weekViewOptions: SohoWeekViewOptions);
    get weekViewOptions(): SohoWeekViewOptions;
    /**
     * Setting to toggle stacked week view layout
     */
    set stacked(isStacked: boolean | undefined);
    get stacked(): boolean | undefined;
    /**
     * Setting to toggle footer when in stacked week view mode
     */
    set showFooter(val: boolean | undefined);
    get showFooter(): boolean | undefined;
    /**
     * Setting to switch to one day view in phone-tablet sizes (stacked mode only)
     */
    set responsive(val: boolean | undefined);
    get responsive(): boolean | undefined;
    /**
     * Setting to hide week view calendar toolbar
     */
    set hideToolbar(val: boolean | undefined);
    get hideToolbar(): boolean | undefined;
    /**
     * An array of objects with data for the event types.
     */
    set eventTypes(eventTypes: SohoWeekViewEventType[] | undefined);
    get eventTypes(): SohoWeekViewEventType[] | undefined;
    /**
     * An array of objects with data for the filtered event types.
     */
    set filteredTypes(filteredTypes: [] | undefined);
    get filteredTypes(): [] | undefined;
    /**
     * An array of objects with data for the events.
     */
    set events(events: SohoWeekViewEvent[] | undefined);
    get events(): SohoWeekViewEvent[] | undefined;
    /**
     * The name of the locale to use for this instance. If not set the current locale will be used.
     */
    set locale(locale: string | undefined);
    get locale(): string | undefined;
    /**
     * Start of the week to show.
     */
    set startDate(startDate: Date | undefined);
    get startDate(): Date | undefined;
    /**
     * End of the week to show
     */
    set endDate(endDate: Date | undefined);
    get endDate(): Date | undefined;
    /**
     * Start of the hour to show.
     */
    set startHour(startHour: number | undefined);
    get startHour(): number | undefined;
    /**
     * End of the hour to show
     */
    set endHour(endHour: number | undefined);
    get endHour(): number | undefined;
    /**
     * Determines if the today button should be shown.
     */
    set showToday(showToday: boolean | undefined);
    get showToday(): boolean | undefined;
    /**
     * Determines if the all day events row should be shown.
     */
    set showAllDay(showAllDay: boolean | undefined);
    get showAllDay(): boolean | undefined;
    /**
     *  If false the dropdown to change views will not be shown.
     */
    set showViewChanger(showViewChanger: boolean | undefined);
    get showViewChanger(): boolean | undefined;
    /**
     * Shows a bar across the current time.
     */
    set showTimeLine(showTimeLine: boolean | undefined);
    get showTimeLine(): boolean | undefined;
    /**
     * Set first day of the week. '1' would be Monday.
     */
    set firstDayOfWeek(firstDayOfWeek: boolean | undefined);
    get firstDayOfWeek(): boolean | undefined;
    /**
     * If false the mouseover text or day event will not be shown.
     */
    set eventTooltip(eventTooltip: string | SohoWeekViewTooltipFunction | undefined);
    get eventTooltip(): string | SohoWeekViewTooltipFunction | undefined;
    /**
     * If false the mouseover text for event icon will not be shown.
     */
    set iconTooltip(iconTooltip: string | SohoWeekViewTooltipFunction | undefined);
    get iconTooltip(): string | SohoWeekViewTooltipFunction | undefined;
    /**
     * Fires when a week view is rendered, allowing you to pass back events or event types to show.
     */
    set renderWeekCallback(renderWeekCallback: Function | undefined);
    get renderWeekCallback(): Function | undefined;
    /**
     * Call back for when the view changer is changed.
     */
    set changeToWeekDayCallback(changeToWeekDayCallback: Function | undefined);
    get changeToWeekDayCallback(): Function | undefined;
    /**
     * Call back for when the week is changed.
     */
    set changeWeekCallback(changeWeekCallback: Function | undefined);
    get changeWeekCallback(): Function | undefined;
    /**
     * Call back for when the view changer is changed.
     */
    set changeViewCallback(changeViewCallback: Function | undefined);
    get changeViewCallback(): Function | undefined;
    /** Add extra attributes like id's to the component **/
    set attributes(attributes: Array<Object> | Object | undefined);
    get attributes(): Array<Object> | Object | undefined;
    constructor(element: ElementRef, ngZone: NgZone, ref: ChangeDetectorRef);
    isCalendarWeekView: boolean;
    selected: EventEmitter<SohoWeekViewDateSelectedEvent>;
    weekRendered: EventEmitter<SohoWeekViewRenderWeekEvent>;
    eventClick: EventEmitter<SohoWeekViewClickEvent>;
    eventDblClick: EventEmitter<SohoWeekViewClickEvent>;
    eventContextMenu: EventEmitter<SohoWeekViewClickEvent>;
    /**
     * Local variables
     */
    private jQueryElement?;
    private weekView;
    private _weekViewOptions;
    private updateRequired?;
    weekviewOptions(weekviewOptions: SohoWeekViewOptions): void;
    ngAfterViewInit(): void;
    ngAfterViewChecked(): void;
    onWeekRenderedEvent(event: SohoWeekViewRenderWeekEvent): void;
    onEventClick(event: SohoWeekViewClickEvent): void;
    onEventDblClick(event: SohoWeekViewClickEvent): void;
    onEventContextMenu(event: SohoWeekViewClickEvent): void;
    /**
     * Get the current selected date on the weekView calendar.
     *
     * @returns the currently selected date on the control.
     */
    currentDate(): Date | undefined;
    /**
     * Get the events and date for the currently selected weekView calendar day.
     *
     * @param date The date to find the events for.
     * @returns dayEvents An object with all the events and the event date.
     */
    getDayEvents(date: Date): SohoWeekViewDayEvents | undefined;
    /**
     * Get dayMap object within weekview component
     * @returns {SohoWeekViewDayMap[]} dayMap object
     */
    getDayMap(): SohoWeekViewDayMap[] | undefined;
    /**
     * Handle updated settings and values.
     */
    updated(settings?: SohoWeekViewOptions): void;
    /**
     * Marks the components as requiring a rebuild after the next update.
     */
    markForRefresh(): void;
    /**
     * Destructor.
     */
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWeekViewComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SohoWeekViewComponent, "div[soho-week-view]", never, { "weekViewOptions": { "alias": "weekViewOptions"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "showFooter": { "alias": "showFooter"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "hideToolbar": { "alias": "hideToolbar"; "required": false; }; "eventTypes": { "alias": "eventTypes"; "required": false; }; "filteredTypes": { "alias": "filteredTypes"; "required": false; }; "events": { "alias": "events"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "startDate": { "alias": "startDate"; "required": false; }; "endDate": { "alias": "endDate"; "required": false; }; "startHour": { "alias": "startHour"; "required": false; }; "endHour": { "alias": "endHour"; "required": false; }; "showToday": { "alias": "showToday"; "required": false; }; "showAllDay": { "alias": "showAllDay"; "required": false; }; "showViewChanger": { "alias": "showViewChanger"; "required": false; }; "showTimeLine": { "alias": "showTimeLine"; "required": false; }; "firstDayOfWeek": { "alias": "firstDayOfWeek"; "required": false; }; "eventTooltip": { "alias": "eventTooltip"; "required": false; }; "iconTooltip": { "alias": "iconTooltip"; "required": false; }; "renderWeekCallback": { "alias": "renderWeekCallback"; "required": false; }; "changeToWeekDayCallback": { "alias": "changeToWeekDayCallback"; "required": false; }; "changeWeekCallback": { "alias": "changeWeekCallback"; "required": false; }; "changeViewCallback": { "alias": "changeViewCallback"; "required": false; }; "attributes": { "alias": "attributes"; "required": false; }; "weekviewOptions": { "alias": "weekviewOptions"; "required": false; }; }, { "selected": "selected"; "weekRendered": "weekRendered"; "eventClick": "eventClick"; "eventDblClick": "eventDblClick"; "eventContextMenu": "eventContextMenu"; }, never, ["*"], true, never>;
}

declare class SohoWeekViewModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoWeekViewModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoWeekViewModule, never, [typeof SohoWeekViewComponent], [typeof SohoWeekViewComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoWeekViewModule>;
}

declare class SohoVersionInitializerModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoVersionInitializerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoVersionInitializerModule, never, never, never>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoVersionInitializerModule>;
}

declare class SohoComponentsModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<SohoComponentsModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<SohoComponentsModule, never, [typeof SohoAboutModule, typeof SohoAccordionModule, typeof SohoActionsheetModule, typeof SohoAlertModule, typeof SohoApplicationMenuModule, typeof SohoArrangeModule, typeof SohoAutoCompleteModule, typeof SohoBarModule, typeof SohoBlockGridModule, typeof SohoBreadcrumbModule, typeof SohoBulletModule, typeof SohoBusyIndicatorModule, typeof SohoButtonModule, typeof SohoButtonsetModule, typeof SohoCalendarModule, typeof SohoChartModule, typeof SohoCheckBoxModule, typeof SohoCardModule, typeof SohoCirclepagerModule, typeof SohoColorPickerModule, typeof SohoColumnModule, typeof SohoContextualActionPanelModule, typeof SohoContextMenuModule, typeof SohoDataGridModule, typeof SohoDatePickerModule, typeof SohoDragModule, typeof SohoDropDownModule, typeof SohoEditorModule, typeof SohoEmptyMessageModule, typeof SohoErrorModule, typeof SohoExpandableAreaModule, typeof SohoFieldFilterModule, typeof SohoFieldOptionsModule, typeof SohoFieldSetModule, typeof SohoFileUploadAdvancedModule, typeof SohoFileUploadModule, typeof SohoFormCompactModule, typeof SohoHeaderModule, typeof SohoHierarchyModule, typeof SohoHomePageModule, typeof SohoHyperlinkModule, typeof SohoIconModule, typeof SohoInputModule, typeof SohoInputValidateModule, typeof SohoLabelModule, typeof SohoLineModule, typeof SohoListViewModule, typeof SohoListBuilderModule, typeof SohoLocaleModule, typeof SohoLookupModule, typeof SohoMaskModule, typeof SohoMastheadModule, typeof SohoMenuButtonModule, typeof SohoMessageModule, typeof SohoModalDialogModule, typeof SohoModuleNavModule, typeof SohoModuleNavContainerModule, typeof SohoModuleNavSettingsModule, typeof SohoModuleNavSwitcherModule, typeof SohoMonthViewModule, typeof SohoNotificationModule, typeof SohoNotificationBadgeModule, typeof SohoPagerModule, typeof SohoPersonalizeModule, typeof SohoPieModule, typeof SohoPopDownModule, typeof SohoPopupMenuModule, typeof SohoProgressModule, typeof SohoRadarModule, typeof SohoRadioButtonModule, typeof SohoRatingModule, typeof SohoRenderLoopModule, typeof SohoSearchFieldModule, typeof SohoSparklineModule, typeof SohoSplitterModule, typeof SohoSliderModule, typeof SohoSpinboxModule, typeof SohoStepChartModule, typeof SohoStepProcessModule, typeof SohoSwapListModule, typeof SohoSwipeActionModule, typeof SohoTabsModule, typeof SohoTagModule, typeof SohoTextAreaModule, typeof SohoTimelineModule, typeof SohoTimePickerModule, typeof SohoToastModule, typeof SohoToolbarModule, typeof SohoToolbarFlexModule, typeof SohoTooltipModule, typeof SohoTrackDirtyModule, typeof SohoTreeModule, typeof SohoTreemapModule, typeof SohoWeekViewModule, typeof SohoWizardModule], [typeof SohoAboutModule, typeof SohoAccordionModule, typeof SohoActionsheetModule, typeof SohoAlertModule, typeof SohoApplicationMenuModule, typeof SohoArrangeModule, typeof SohoAutoCompleteModule, typeof SohoBarModule, typeof SohoBlockGridModule, typeof SohoBreadcrumbModule, typeof SohoBulletModule, typeof SohoBusyIndicatorModule, typeof SohoButtonModule, typeof SohoButtonsetModule, typeof SohoCalendarModule, typeof SohoCardModule, typeof SohoChartModule, typeof SohoCheckBoxModule, typeof SohoCirclepagerModule, typeof SohoColorPickerModule, typeof SohoColumnModule, typeof SohoContextMenuModule, typeof SohoContextualActionPanelModule, typeof SohoDataGridModule, typeof SohoDatePickerModule, typeof SohoDragModule, typeof SohoDropDownModule, typeof SohoEditorModule, typeof SohoEmptyMessageModule, typeof SohoErrorModule, typeof SohoExpandableAreaModule, typeof SohoFieldFilterModule, typeof SohoFieldOptionsModule, typeof SohoFieldSetModule, typeof SohoFileUploadAdvancedModule, typeof SohoFileUploadModule, typeof SohoFormCompactModule, typeof SohoHeaderModule, typeof SohoHierarchyModule, typeof SohoHomePageModule, typeof SohoHyperlinkModule, typeof SohoIconModule, typeof SohoInputModule, typeof SohoInputValidateModule, typeof SohoLabelModule, typeof SohoLineModule, typeof SohoListViewModule, typeof SohoListBuilderModule, typeof SohoLocaleModule, typeof SohoLookupModule, typeof SohoMaskModule, typeof SohoMastheadModule, typeof SohoMenuButtonModule, typeof SohoModalDialogModule, typeof SohoModuleNavModule, typeof SohoModuleNavContainerModule, typeof SohoModuleNavSettingsModule, typeof SohoModuleNavSwitcherModule, typeof SohoMonthViewModule, typeof SohoNotificationModule, typeof SohoNotificationBadgeModule, typeof SohoPagerModule, typeof SohoPersonalizeModule, typeof SohoPieModule, typeof SohoPopDownModule, typeof SohoPopupMenuModule, typeof SohoProgressModule, typeof SohoRadarModule, typeof SohoRadioButtonModule, typeof SohoRatingModule, typeof SohoRenderLoopModule, typeof SohoSearchFieldModule, typeof SohoSliderModule, typeof SohoSparklineModule, typeof SohoSplitterModule, typeof SohoSpinboxModule, typeof SohoStepChartModule, typeof SohoStepProcessModule, typeof SohoSwapListModule, typeof SohoSwipeActionModule, typeof SohoTabsModule, typeof SohoTagModule, typeof SohoTextAreaModule, typeof SohoTimelineModule, typeof SohoTimePickerModule, typeof SohoToastModule, typeof SohoToolbarModule, typeof SohoToolbarFlexModule, typeof SohoTooltipModule, typeof SohoTrackDirtyModule, typeof SohoTreeModule, typeof SohoTreemapModule, typeof SohoVersionInitializerModule, typeof SohoWeekViewModule, typeof SohoWizardModule]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<SohoComponentsModule>;
}

export { ArgumentHelper, BaseControlValueAccessor, DeprecatedEventEmitter, ExpandableAreaComponent, ExpandableFooterComponent, ExpandableHeaderComponent, ExpandablePaneComponent, NOOP, SohoAboutModule, SohoAboutRef, SohoAboutService, SohoAccordionComponent, SohoAccordionHeaderComponent, SohoAccordionModule, SohoAccordionPaneComponent, SohoActionsheetComponent, SohoActionsheetModule, SohoAlertDirective, SohoAlertModule, SohoAngularEditorAdapter, SohoApplicationMenuComponent, SohoApplicationMenuModule, SohoArrangeDirective, SohoArrangeModule, SohoAutoCompleteComponent, SohoAutoCompleteModule, SohoBarComponent, SohoBarModule, SohoBlockGridComponent, SohoBlockGridModule, SohoBreadcrumbComponent, SohoBreadcrumbListComponent, SohoBreadcrumbModule, SohoBulletComponent, SohoBulletModule, SohoBusyIndicatorDirective, SohoBusyIndicatorModule, SohoButtonComponent, SohoButtonModule, SohoButtonsetComponent, SohoButtonsetModule, SohoCalendarComponent, SohoCalendarModule, SohoCalendarMonthViewComponent, SohoCalendarWeekViewComponent, SohoCardActionableComponent, SohoCardComponent, SohoCardContentComponent, SohoCardHeaderComponent, SohoCardModule, SohoCardPaneComponent, SohoCardsComponent, SohoChartComponent, SohoChartModule, SohoCheckBoxComponent, SohoCheckBoxModule, SohoCirclepagerComponent, SohoCirclepagerModule, SohoColorPickerComponent, SohoColorPickerModule, SohoColumnComponent, SohoColumnModule, SohoComponentsModule, SohoContextMenuDirective, SohoContextMenuHeadingComponent, SohoContextMenuItemComponent, SohoContextMenuItemLabelComponent, SohoContextMenuModule, SohoContextMenuSeparatorComponent, SohoContextMenuShortCutTextComponent, SohoContextualActionPanelModule, SohoContextualActionPanelRef, SohoContextualActionPanelService, SohoDataGridComponent, SohoDataGridModule, SohoDataGridService, SohoDatePickerComponent, SohoDatePickerModule, SohoDragDirective, SohoDragModule, SohoDropDownComponent, SohoDropDownModule, SohoEditorComponent, SohoEditorModule, SohoEmptyMessageDirective, SohoEmptyMessageModule, SohoErrorDirective, SohoErrorModule, SohoExpandableAreaModule, SohoFieldFilterDirective, SohoFieldFilterModule, SohoFieldOptionsDirective, SohoFieldOptionsModule, SohoFieldSetModule, SohoFileUploadAdvancedComponent, SohoFileUploadAdvancedModule, SohoFileUploadComponent, SohoFileUploadModule, SohoFormCompactComponent, SohoFormCompactModule, SohoFormatDatePipe, SohoFormatNumberPipe, SohoHeaderComponent, SohoHeaderModule, SohoHierarchyComponent, SohoHierarchyLeafTemplateComponent, SohoHierarchyModule, SohoHomePageComponent, SohoHomePageModule, SohoHomepageSizerDirective, SohoHyperlinkComponent, SohoHyperlinkModule, SohoIconComponent, SohoIconModule, SohoIconUseComponent, SohoIconUtils, SohoIconsAppComponent, SohoIconsComponent, SohoIconsEmptyClassicComponent, SohoIconsEmptyComponent, SohoIconsEmptyNewComponent, SohoIconsEmptyUpliftComponent, SohoIconsExtendedComponent, SohoIconsNewComponent, SohoIconsUpliftComponent, SohoInputComponent, SohoInputModule, SohoInputValidateDirective, SohoInputValidateModule, SohoLabelDirective, SohoLabelModule, SohoLineComponent, SohoLineModule, SohoListBuilderComponent, SohoListBuilderModule, SohoListViewComponent, SohoListViewHeaderComponent, SohoListViewItemComponent, SohoListViewMicroComponent, SohoListViewModule, SohoListViewSearchComponent, SohoListViewSubHeaderComponent, SohoLocaleModule, SohoLookupComponent, SohoLookupModule, SohoMaskDirective, SohoMaskModule, SohoMastheadComponent, SohoMastheadModule, SohoMenuButtonComponent, SohoMenuButtonModule, SohoMessageModule, SohoMessageRef, SohoMessageService, SohoModalDialogModule, SohoModalDialogRef, SohoModalDialogService, SohoModuleNavComponent, SohoModuleNavContainerComponent, SohoModuleNavContainerModule, SohoModuleNavModule, SohoModuleNavSettingsComponent, SohoModuleNavSettingsModule, SohoModuleNavSwitcherComponent, SohoModuleNavSwitcherModule, SohoMonthViewComponent, SohoMonthViewModule, SohoNotificationBadgeComponent, SohoNotificationBadgeModule, SohoNotificationModule, SohoNotificationService, SohoPageTitleComponent, SohoPagerModule, SohoPersonalizeDirective, SohoPersonalizeModule, SohoPieComponent, SohoPieModule, SohoPopDownContentsComponent, SohoPopDownDirective, SohoPopDownModule, SohoPopupMenuComponent, SohoPopupMenuHeadingComponent, SohoPopupMenuItemComponent, SohoPopupMenuItemLabelComponent, SohoPopupMenuModule, SohoPopupMenuSeparatorComponent, SohoPopupMenuShortCutTextComponent, SohoProgressComponent, SohoProgressModule, SohoRadarComponent, SohoRadarModule, SohoRadioButtonComponent, SohoRadioButtonModule, SohoRatingComponent, SohoRatingModule, SohoRenderLoopModule, SohoRenderLoopService, SohoRevealableTextMaskDirective, SohoSearchFieldComponent, SohoSearchFieldModule, SohoSearchFieldWrapperComponent, SohoSectionTitleComponent, SohoSelectionCountComponent, SohoSliderComponent, SohoSliderModule, SohoSparklineComponent, SohoSparklineModule, SohoSpinboxComponent, SohoSpinboxModule, SohoSplitterComponent, SohoSplitterModule, SohoStandalonePagerComponent, SohoStepChartComponent, SohoStepChartModule, SohoStepContentComponent, SohoStepContentPanelComponent, SohoStepContentTitleComponent, SohoStepListComponent, SohoStepListItemAnchorComponent, SohoStepListItemComponent, SohoStepListItemTitleComponent, SohoStepListTitleComponent, SohoStepProcessComponent, SohoStepProcessModule, SohoSubstepListComponent, SohoSwapListCardComponent, SohoSwapListComponent, SohoSwapListModule, SohoSwapListService, SohoSwipeActionComponent, SohoSwipeActionModule, SohoTabComponent, SohoTabCountComponent, SohoTabListComponent, SohoTabListContainerComponent, SohoTabPanelComponent, SohoTabPanelContainerComponent, SohoTabSeparatorComponent, SohoTabTitleComponent, SohoTabsComponent, SohoTabsModule, SohoTagComponent, SohoTagListComponent, SohoTagModule, SohoTextAreaComponent, SohoTextAreaModule, SohoTimePickerComponent, SohoTimePickerModule, SohoTimelineComponent, SohoTimelineModule, SohoToastModule, SohoToastService, SohoToolbarButtonSetComponent, SohoToolbarComponent, SohoToolbarFlexComponent, SohoToolbarFlexModule, SohoToolbarFlexMoreButtonComponent, SohoToolbarFlexNavButtonComponent, SohoToolbarFlexPageTitleComponent, SohoToolbarFlexSearchFieldComponent, SohoToolbarFlexSectionComponent, SohoToolbarFlexSectionTitleComponent, SohoToolbarModule, SohoToolbarMoreButtonComponent, SohoToolbarNavButtonComponent, SohoToolbarSearchFieldComponent, SohoToolbarSearchFieldWrapperComponent, SohoToolbarTitleComponent, SohoTooltipDirective, SohoTooltipModule, SohoTrackDirtyDirective, SohoTrackDirtyModule, SohoTranslatePipe, SohoTreeComponent, SohoTreeModule, SohoTreeService, SohoTreemapComponent, SohoTreemapModule, SohoVersionInitializerModule, SohoWeekViewComponent, SohoWeekViewModule, SohoWidgetComponent, SohoWidgetContentComponent, SohoWidgetHeaderComponent, SohoWidgetTitleComponent, SohoWizardButtonbarComponent, SohoWizardComponent, SohoWizardHeaderComponent, SohoWizardModule, SohoWizardPageComponent, SohoWizardPagesComponent, SohoWizardTickComponent, TestHelper, provideControlValueAccessor };
export type { ComponentType, PanelComponentType, SohoAboutDialogEventGuard, SohoBusyIndicatorEvent, SohoButtonType, SohoContextualActionPanelComponent, SohoContextualActionPanelEventFunction, SohoDataGridKeyDownEvent, SohoDataGridToggleRowEvent, SohoHyperlinkType, SohoModalComponent, SohoModalDialogEventFunction, SohoModalDialogEventVetoFunction, SohoModalDialogVetoableEventGuard, SohoSwapListCardType, SohoTagType, WidgetSize };