@watermarkinsights/ripple 0.0.0 → 0.1.0-alpha.0

package/dist/types/components/charts/wm-chart-bar/wm-chart-bar.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+import { ChartConfig, ChartData, ProcessedChartData, ChartGridInfo, ProcessedChartDataGrouped } from "../../../global/interfaces";
+export declare class ChartBar {
+    el: HTMLWmChartBarElement;
+    private barAreaEl;
+    private popoverEl;
+    private componentWrapperEl;
+    private gridMax;
+    private isGrouped;
+    private legendData;
+    private ungroupedDataName;
+    config?: ChartConfig;
+    data?: ChartData[];
+    printMode?: boolean;
+    subinfo?: string;
+    processedData: ProcessedChartDataGrouped;
+    gridInfo?: ChartGridInfo;
+    isKeying: boolean;
+    wmChartBarHighlighted: EventEmitter<{
+        idx: number;
+    }>;
+    get colorPalette(): string[];
+    get sort(): "ascending" | "descending" | "none";
+    get showLegend(): "left" | "right" | "top" | "bottom" | "none";
+    get subinfoText(): string;
+    get gridVisible(): boolean;
+    get flattenedData(): ProcessedChartData[];
+    componentDidLoad(): void;
+    handleConfigDataChange(): void;
+    processChartData(): ProcessedChartData[];
+    propagateExternalLegendData(): void;
+    calculateGridInfo(): ChartGridInfo;
+    handleChartKeyDown(ev: KeyboardEvent): void;
+    handleBarKeyDown(ev: KeyboardEvent, item: ProcessedChartData): void;
+    handleBarClick(ev: MouseEvent, item: ProcessedChartData): void;
+    handleLegendItemClick(ev: CustomEvent<{
+        idx: number;
+    }>): void;
+    handleDocumentClick(_ev: MouseEvent): void;
+    handleUserIsKeying(): void;
+    handleUserIsNotKeying(): void;
+    handleComponentBlur(ev: FocusEvent): void;
+    focusBar(barIdx: number): void;
+    handlePopoverToggled(_ev: CustomEvent): void;
+    openPopover(clickedProcessedData: ProcessedChartData, coords: {
+        x: number;
+        y: number;
+    }): void;
+    clearHighlights(): void;
+    highlightBar(item: ProcessedChartData): void;
+    highlightBarsByLegend(barLegend: string): void;
+    clearFocus(): void;
+    renderBarLegends(): HTMLDivElement[];
+    renderBar(item: ProcessedChartData, effectiveGridMax: number): any;
+    renderBars(): HTMLDivElement[] | undefined;
+    renderGroupLegends(): HTMLDivElement[];
+    renderGroupedBars(): HTMLDivElement[] | undefined;
+    renderXAxis(): any;
+    renderGrid(): any;
+    renderLegend(orientation: "horizontal" | "vertical"): any;
+    render(): any;
+}

package/dist/types/components/charts/wm-chart-column/wm-chart-column.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+import { ChartConfig, ChartData, ProcessedChartData, ChartGridInfo, ProcessedChartDataGrouped } from "../../../global/interfaces";
+export declare class ChartColumn {
+    el: HTMLWmChartColumnElement;
+    private barAreaEl;
+    private scrollableAreaEl;
+    private popoverEl;
+    private componentWrapperEl;
+    private gridMax;
+    private isGrouped;
+    private legendData;
+    private ungroupedDataName;
+    config?: ChartConfig;
+    data?: ChartData[];
+    printMode?: boolean;
+    subinfo?: string;
+    processedData: ProcessedChartDataGrouped;
+    gridInfo?: ChartGridInfo;
+    isKeying: boolean;
+    wmChartBarHighlighted: EventEmitter<{
+        idx: number;
+    }>;
+    get colorPalette(): string[];
+    get sort(): "ascending" | "descending" | "none";
+    get showLegend(): "left" | "right" | "top" | "bottom" | "none";
+    get subinfoText(): string;
+    get gridVisible(): boolean;
+    get flattenedData(): ProcessedChartData[];
+    get columnCount(): number;
+    componentDidLoad(): void;
+    updateColumnWidth(): void;
+    updateGroupedColumnGap(): void;
+    handleConfigDataChange(): void;
+    processChartData(): ProcessedChartData[];
+    propagateExternalLegendData(): void;
+    calculateGridInfo(): ChartGridInfo;
+    handleChartKeyDown(ev: KeyboardEvent): void;
+    handleBarKeyDown(ev: KeyboardEvent, item: ProcessedChartData): void;
+    handleBarClick(ev: MouseEvent, item: ProcessedChartData): void;
+    handleLegendItemClick(ev: CustomEvent<{
+        idx: number;
+    }>): void;
+    handleLegendItemHover(ev: CustomEvent<{
+        idx: number;
+    }>): void;
+    handleLegendFocus(idx: number): void;
+    handleDocumentClick(_ev: MouseEvent): void;
+    applyScrollFade(): void;
+    debouncedHandleResize: (this: any) => void;
+    handleUserIsKeying(): void;
+    handleUserIsNotKeying(): void;
+    handleComponentBlur(ev: FocusEvent): void;
+    focusBar(barIdx: number): void;
+    scrollToBar(barIdx: number): void;
+    handlePopoverToggled(_ev: CustomEvent): void;
+    openPopover(clickedProcessedData: ProcessedChartData, coords: {
+        x: number;
+        y: number;
+    }): void;
+    clearHighlights(): void;
+    highlightBar(item: ProcessedChartData): void;
+    highlightBarsByLegend(barLegend: string): void;
+    clearFocus(): void;
+    renderBarLegends(): HTMLDivElement[];
+    renderColumns(): HTMLDivElement[] | undefined;
+    renderXAxis(): any;
+    renderGroupedXAxis(): any;
+    renderGroupedColumns(): HTMLDivElement[] | undefined;
+    renderGrid(): any;
+    renderYAxis(): any;
+    renderLegend(orientation: "horizontal" | "vertical"): any;
+    render(): any;
+}

package/dist/types/components/charts/wm-chart-legend/wm-chart-legend.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+import { ProcessedChartData } from "../../../global/interfaces";
+export declare class ChartLegend {
+    el: HTMLWmChartLegendElement;
+    chartIds: string;
+    orientation: "horizontal" | "vertical";
+    processedData: ProcessedChartData[];
+    printMode: boolean;
+    private persistentHighlightIdx;
+    wmLegendItemClick: EventEmitter<{
+        idx: number;
+    }>;
+    wmLegendItemHover: EventEmitter<{
+        idx: number;
+    }>;
+    handleChartBarHighlighted(ev: CustomEvent<{
+        idx: number;
+    }>): void;
+    handleDocumentClick(_ev: MouseEvent): void;
+    highlightLegendItem(highlightedIdx: number): void;
+    handleLegendItemClick(idx: number): void;
+    handleLegendItemMouseEnter(idx: number): void;
+    handleLegendItemMouseLeave(): void;
+    renderLegendItems(): any[];
+    render(): any;
+}

package/dist/types/components/charts/wm-line-chart/wm-line-chart.d.ts

@@ -0,0 +1,87 @@
+import { DataPointDetails, Line, LineChartData, SpotlightData } from "../../../global/interfaces";
+export declare class LineChart {
+    el: HTMLWmLineChartElement;
+    private plotAreaEl;
+    private legendEl;
+    private popoverEl;
+    private yIntervalsEl;
+    private liveRegionEl;
+    label: string;
+    description: string;
+    xAxisLabel: string;
+    yAxisLabel: string;
+    showGrid: boolean;
+    lineData: string | LineChartData;
+    units: string;
+    labelWidth: string;
+    highlightQualifier: string;
+    highlightStart?: string;
+    highlightEnd?: string;
+    visibilityToggles: boolean;
+    showDeltas: boolean;
+    yRange?: string;
+    spotlightData?: SpotlightData;
+    decimalPlaces?: number;
+    parsedLineData: LineChartData;
+    popoverIndex: number;
+    focusedLine: number;
+    hiddenLines: number[];
+    isTabbing: boolean;
+    announcement: string;
+    private minTickWidth;
+    private lineStyles;
+    get xIntervals(): string[];
+    get yIntervals(): number[];
+    get intervalInfo(): {
+        skipInterval: number;
+        skippedList: string[];
+    };
+    get displayedXIntervals(): string[];
+    get dataPointMatrix(): DataPointDetails[][];
+    get popoverData(): DataPointDetails[][];
+    get spotlightXValue(): string | undefined;
+    get spotlightYValue(): number | undefined;
+    parseData(): void;
+    get hasPartialInterval(): boolean;
+    get parsedUnits(): (string | null)[];
+    get visibilityToggleEls(): NodeListOf<HTMLWmButtonElement>;
+    get lineEls(): NodeListOf<HTMLDivElement>;
+    get firstVisibleLineIdx(): number;
+    get pointEls(): NodeListOf<HTMLSpanElement>;
+    toggleTabbingOn(): void;
+    toggleTabbingOff(): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    debouncedResize: (this: any) => void;
+    handleVisibilityToggleKeydown(ev: KeyboardEvent, toggleIdx: number): void;
+    handleDataPointKeydown(ev: KeyboardEvent): void;
+    navigatePointsVertically(originPoint: HTMLElement, stepAmount: number): void;
+    navigatePointsHorizontally(originPoint: HTMLElement, stepAmount: number): void;
+    announce(message: string): void;
+    lineFocusMessage(lineIdx: number): string;
+    focusDataPointByEl(pointEl: HTMLElement): void;
+    formatDisplayYValue(yValue: number): string;
+    formatYAxisIntervalLabel(intervalValue: number): string;
+    buildLineDataPointDetails(lineLabel: string, line: Line): DataPointDetails[];
+    toggleLineVisibility(lineIdx: number): void;
+    resetDataPointFocus(): void;
+    calcDelta(dataPoint: DataPointDetails, prevDataPoint: DataPointDetails): string;
+    renderLegend(): any;
+    renderVisibilityToggle(lineLabel: string, lineIdx: number, isHidden: boolean): any;
+    renderIcon(lineIdx: number): any;
+    renderXIntervals(): any;
+    renderYIntervals(): any;
+    renderData(): any[];
+    renderPoints(lineIdx: number): any;
+    renderLines(lineIdx: number): any;
+    renderSpotlight(): any;
+    renderHoverAreas(): any;
+    renderPopover(): any;
+    renderPopoverTable(): any;
+    renderDeltas(dataPoint: DataPointDetails, prevDataPoint: DataPointDetails): any;
+    renderHoverIndicator(): any;
+    renderVerticalGridlines(): any;
+    renderHorizontalGridlines(): any;
+    renderHighlight(): any;
+    render(): any;
+}

package/dist/types/components/charts/wm-progress-monitor/wm-progress-indicator.d.ts

@@ -0,0 +1,34 @@
+import { ChartDetails } from "../../../global/interfaces";
+export declare class ProgressIndicator {
+    el: HTMLWmProgressIndicatorElement;
+    private componentWrapperEl;
+    label?: string;
+    subinfo?: string;
+    completionMessage?: string;
+    showLegend: boolean;
+    printMode: boolean;
+    printModeFormat: "amount" | "percentage";
+    isTabbing: boolean;
+    mode?: "doughnut" | "bar";
+    userIsNavigating: boolean;
+    focusedSliceId?: string;
+    private uid;
+    private total;
+    private slicesDetails;
+    get popoverEl(): HTMLPrivChartPopoverOldElement | null;
+    get sliceEls(): (SVGElement | HTMLElement)[] | undefined;
+    get chartDetails(): ChartDetails | undefined;
+    get ariaLabelText(): string;
+    get chartRoleDescription(): string;
+    toggleTabbingOn(): void;
+    toggleTabbingOff(): void;
+    handleKeydown(ev: KeyboardEvent): void;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    debouncedUpdate: (this: any) => void;
+    handleSliceUpdate(): Promise<void>;
+    handleModeUpdate(): void;
+    handlePopoverOpenChanged(ev: CustomEvent): void;
+    renderBarOrDoughnut(): any;
+    render(): any;
+}

package/dist/types/components/charts/wm-progress-monitor/wm-progress-monitor.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class ProgressMonitor {
+    el: HTMLWmProgressMonitorElement;
+    breakpoint?: number | string;
+    groupLegend?: string;
+    barLabelsWidth?: string;
+    wmProgressMonitorModeChange: EventEmitter;
+    private doughnutWidth;
+    private prevMode?;
+    private modeInitialized;
+    get parsedBreakpoint(): number;
+    get mode(): "doughnut" | "bar";
+    get isBar(): boolean;
+    get isDoughnut(): boolean;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    componentWillUpdate(): void;
+    debouncedUpdate: (this: any) => void;
+    parseToNum(num: string | number): number;
+    renderLegend(): any;
+    render(): any;
+}

package/dist/types/components/charts/wm-progress-monitor/wm-progress-slice.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class ProgressSlice {
+    legend?: string;
+    amount?: string;
+    popoverTitle?: string;
+    popoverText?: string;
+    popoverButtonText?: string;
+    wmProgressSliceUpdated: EventEmitter<void>;
+    componentDidUpdate(): void;
+}

package/dist/types/components/datepickers/priv-calendar/priv-calendar.d.ts

@@ -0,0 +1,89 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class PrivCalendar {
+    el: HTMLPrivCalendarElement;
+    private prevBtnEl;
+    private nextBtnEl;
+    private liveRegionEl;
+    private today;
+    disabled: boolean;
+    view: string;
+    focusDate: string;
+    startDate?: string;
+    endDate?: string;
+    hoverDate?: string;
+    announcement: string;
+    cellTriggered: EventEmitter<{
+        cal: HTMLPrivCalendarElement;
+        cell: HTMLElement;
+    }>;
+    cellHovered: EventEmitter<string>;
+    outOfCal: EventEmitter<string>;
+    popupBlurred: EventEmitter<{
+        relatedTarget: EventTarget | null;
+    }>;
+    dateFocus: EventEmitter;
+    private calType;
+    private calName;
+    private calInstructions;
+    private previousMonthButtonLabel;
+    private previousYearButtonLabel;
+    private nextMonthButtonLabel;
+    private nextYearButtonLabel;
+    private uid;
+    setCalName(): void;
+    setCalType(): void;
+    componentWillLoad(): void;
+    _focus: {
+        year: {
+            asString: () => string;
+            asInt: () => number;
+            set: (y: number) => void;
+            increase: (n: number) => void;
+            decrease: (n: number) => void;
+        };
+        month: {
+            asString: () => string;
+            asInt: () => number;
+            set: (m: number) => void;
+            increase: (n: number) => void;
+            decrease: (n: number) => void;
+        };
+        day: {
+            asString: () => string;
+            asInt: () => number;
+            set: (d: number) => void;
+            increase: (n: number) => void;
+            decrease: (n: number) => void;
+        };
+    };
+    monthButtonFocus: {
+        set: (i: number) => void;
+        increase: (i: number) => void;
+        decrease: (i: number) => void;
+    };
+    handleFocusDate(newVal: string, oldVal: string): void;
+    get otherCalEl(): HTMLPrivCalendarElement | undefined;
+    get headerButtonEls(): HTMLElement[];
+    handleKey(ev: KeyboardEvent): void;
+    handleDateClick(el: HTMLTableDataCellElement): void;
+    removeZeroes(date: string): number;
+    dateToISO(date: Date): string;
+    isInRange(date: string): boolean;
+    isInRangePreview(date: string): boolean;
+    getMonthFirstDay(month: number, year: number): number;
+    getCalendarDates(date: string): any[];
+    getCell(date: string): HTMLTableCellElement;
+    focusFirstFocusable(): Promise<void>;
+    focusLastFocusable(): Promise<void>;
+    focusCell(): Promise<void>;
+    toggleBusyAttribute(state: string): void;
+    announce(message: string): void;
+    announceMonthYear(): void;
+    renderCalendarDate: (date: string, eitherStart?: string, eitherEnd?: string) => any;
+    renderMonth(month: string, index: number): any;
+    renderHeader(): any;
+    renderToggleButton(): any;
+    renderDayView(): any;
+    renderMonthView(): any;
+    render(): any;
+}

package/dist/types/components/datepickers/wm-date-range.d.ts

@@ -0,0 +1,73 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+export declare class DateRange {
+    el: HTMLWmDateRangeElement;
+    private wrapperEl;
+    private liveRegionEl;
+    private startInputEl;
+    private endInputEl;
+    private startCalEl;
+    private endCalEl;
+    private toggleEl;
+    private popupEl;
+    private anchorEl;
+    dateFormat: string;
+    disabled: boolean;
+    errorMessage?: string;
+    invalidStart: boolean;
+    invalidEnd: boolean;
+    labelStart: string;
+    labelEnd: string;
+    preselected?: string;
+    requiredField: boolean;
+    valueStart?: string;
+    valueEnd?: string;
+    wmRangeSelection: EventEmitter;
+    wmStartInputBlur: EventEmitter;
+    wmEndInputBlur: EventEmitter;
+    private date1?;
+    private date2?;
+    private oldFocusVal?;
+    private calWidth;
+    isExpanded: boolean;
+    openUp: boolean;
+    openRight: boolean;
+    isHidden: boolean;
+    canOpen: boolean;
+    private hasAnchor;
+    private readonly popupMinHeight;
+    private measureFit;
+    private checkCanOpen;
+    private formats;
+    get _disabled(): boolean;
+    get focusDates(): string[];
+    isSameMonth(date1?: string, date2?: string): boolean;
+    toJSDate(date: string | undefined): Date | undefined;
+    toISO(date: string | undefined): string;
+    handleDisabled(): void;
+    updateValueStart(): void;
+    updateValueEnd(): void;
+    handleErrorMessage(): void;
+    positionDropdown(): void;
+    handleToggle(ev: ToggleEvent): void;
+    closePopup(returnFocus?: boolean): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    handleStartInputBlur(): void;
+    handleEndInputBlur(): void;
+    handleStartInput(ev: Event): void;
+    handleEndInput(ev: Event): void;
+    handleDateFocus(ev: CustomEvent): void;
+    handlePopupBlurred(ev: CustomEvent): void;
+    handleCellTriggered(ev: CustomEvent): void;
+    handleOutOfCal(): void;
+    handleCellHovered(ev: CustomEvent): void;
+    reformatDate(inputFormat: string, outputFormat: string, date?: string): Promise<string>;
+    _reformatDate(inputFormat: string, outputFormat: string, date?: string): string;
+    isValidISO(input?: string): Promise<boolean>;
+    _isValidISO(input?: string): boolean;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    announce(message: string): void;
+    render(): any;
+}

package/dist/types/components/datepickers/wm-datepicker.d.ts

@@ -0,0 +1,54 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+export declare class DatePicker {
+    el: HTMLWmDatepickerElement;
+    private liveRegionEl;
+    private dpWrapperEl;
+    private inputEl;
+    private calEl;
+    private toggleEl;
+    private popupEl;
+    private anchorEl;
+    value?: string;
+    disabled: boolean;
+    dateFormat: string;
+    errorMessage?: string;
+    labelPosition: "top" | "left" | "none";
+    label: string;
+    requiredField: boolean;
+    preselected?: string;
+    wmDatepickerDateSelected: EventEmitter;
+    wmDatepickerInputBlurred: EventEmitter;
+    isExpanded: boolean;
+    openUp: boolean;
+    openRight: boolean;
+    isHidden: boolean;
+    canOpen: boolean;
+    private hasAnchor;
+    private readonly popupMinHeight;
+    private readonly popupWidth;
+    private measureFit;
+    private checkCanOpen;
+    get isDisabled(): boolean;
+    get calendarDate(): string;
+    handleDisabledChange(): void;
+    updateValue(): void;
+    announceError(): void;
+    positionDropdown(): void;
+    handleToggle(ev: ToggleEvent): void;
+    closePopup(returnFocus?: boolean): void;
+    handleInput(ev: Event): void;
+    handleInputBlur(): void;
+    handleInputFocus(): void;
+    handleInputChange(): void;
+    handleLabelMouseEnter(ev: MouseEvent): void;
+    handleCellTriggered(ev: CustomEvent): void;
+    reformatDate(inputFormat: string, outputFormat: string, date?: string): Promise<string>;
+    reformatDateInternal(inputFormat: string, outputFormat: string, date?: string): string;
+    isValidIso(input?: string): Promise<boolean>;
+    isValidIsoInternal(input?: string): boolean;
+    componentWillLoad(): void;
+    componentDidLoad(): void;
+    disconnectedCallback(): void;
+    announce(message: string): void;
+    render(): any;
+}

package/dist/types/components/selects/priv-option-list/priv-option-list.d.ts

@@ -0,0 +1,71 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class PrivOptionList {
+    el: HTMLPrivOptionListElement;
+    private searchFieldWrapperEl;
+    private searchFieldEl;
+    private listboxEl;
+    private selectAllEl;
+    private liveRegionEl;
+    private returnBtnEl;
+    optionListSearchChanged: EventEmitter<Object>;
+    optionListCloseRequested: EventEmitter;
+    optionListAllSelected: EventEmitter;
+    optionListAllDeselected: EventEmitter;
+    wmEscKeyPressed: EventEmitter;
+    wmKeyLeftPressed: EventEmitter;
+    multiple: boolean;
+    search: boolean;
+    selectAll: boolean;
+    searchPlaceholder?: string;
+    optgroupLabel?: string;
+    maxHeight: string;
+    upwardsHeightLimit: number | null;
+    announcement: string;
+    searchTerm: string;
+    private searchIndex;
+    private keysSoFar;
+    get childOptions(): HTMLWmOptionElement[];
+    get cloneOptions(): HTMLWmOptionElement[];
+    get allOptionEls(): HTMLWmOptionElement[];
+    get isInNestedSelect(): boolean;
+    get visibleOptionEls(): HTMLWmOptionElement[];
+    get filteredOptions(): HTMLWmOptionElement[];
+    get selectedOptions(): HTMLWmOptionElement[];
+    get visibleSelectAllButton(): boolean;
+    get allSelected(): boolean;
+    get effectiveMaxHeight(): string;
+    debouncedSearch: (this: any) => void;
+    debouncedClearKeysSoFar: (this: any) => void;
+    findAndFocusOption(ev: CustomEvent): void;
+    handleOptionSelection(ev: CustomEvent): void;
+    handleChildUp(ev: CustomEvent): void;
+    handleChildDown(ev: CustomEvent): void;
+    moveToFirstOption(): void;
+    moveToLastOption(): void;
+    handleOptionCloneSelection(ev: CustomEvent): void;
+    componentDidLoad(): void;
+    handleChildChange(): Promise<void>;
+    clearSearch(): Promise<void>;
+    focusOption(option: HTMLElement): Promise<void>;
+    handleInitialFocus(optionToSelect?: "next" | "previous"): Promise<void>;
+    unfocusAll(): Promise<void>;
+    findMatchInRange(list: HTMLWmOptionElement[], startIndex: number, endIndex: number): HTMLWmOptionElement | null;
+    findCorrespondingOption(el: HTMLWmOptionElement): HTMLWmOptionElement;
+    handleSearchFieldBlur(ev: FocusEvent): void;
+    handleKeyDown(ev: KeyboardEvent): void;
+    close(): void;
+    handleSelectAllClick(): void;
+    selectAllOptions(): void;
+    deselectAllOptions(): void;
+    moveUp(el: HTMLElement): void;
+    moveDown(el: HTMLElement): void;
+    updateOptionVisibility(): Promise<void>;
+    announce(message: string): void;
+    renderReturnBtn(): any;
+    renderSearchField(): any;
+    renderSearchFailedMessage(): any;
+    renderSelectAllButton(): any;
+    renderCloneOptions(): any[];
+    renderNonOptions(): any;
+    render(): any;
+}

package/dist/types/components/selects/wm-nested-select/wm-nested-select.d.ts

@@ -0,0 +1,62 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class NestedSelect {
+    el: HTMLWmNestedSelectElement;
+    private buttonEl;
+    private dropdownEl;
+    private menuEl;
+    private measurementAreaEl;
+    private liveRegionEl;
+    wmNestedSelectBlurred: EventEmitter<void>;
+    disabled: boolean;
+    maxHeight: string;
+    label?: string;
+    labelPosition: "top" | "left" | "none";
+    requiredField: boolean;
+    errorMessage?: string;
+    multiple: boolean;
+    search: boolean;
+    selectAll: boolean;
+    placeholder: string;
+    searchPlaceholder: string;
+    allSelectedMessage: string;
+    isExpanded: boolean;
+    isGroupExpanded: boolean;
+    showClearSelectionButton: boolean;
+    announcement: string;
+    private openUp;
+    constrainedMaxHeight: string;
+    get isDisabled(): boolean;
+    get childOptions(): HTMLWmOptionElement[];
+    get optgroupEls(): HTMLWmOptgroupElement[];
+    get menuitemEls(): HTMLElement[];
+    private overflowCount;
+    private displayedOptions;
+    get allSelected(): boolean;
+    private clearSelectionMessage;
+    componentWillLoad(): void;
+    handleChildChange(): void;
+    setButtonText(): void;
+    countOptgroupSelected(optgroupEl: HTMLWmOptgroupElement): number;
+    handleOptionSelection(): void;
+    handleChildEnter(): void;
+    closePopupOnEscape(): void;
+    handleKeyDown(ev: KeyboardEvent): void;
+    close(returnFocus?: boolean): void;
+    open(focusLast?: boolean): void;
+    moveDown(menuitemEl: HTMLElement): void;
+    moveUp(menuitemEl: HTMLElement): void;
+    handleButtonBlur(ev: FocusEvent): void;
+    handleClick(ev: MouseEvent): void;
+    handleMenuitemKeydown(ev: KeyboardEvent): void;
+    handleComponentBlur(ev: FocusEvent): void;
+    handleLabelMouseEnter(ev: MouseEvent): void;
+    handleOptgroupExpanded(): void;
+    handleOptgroupHidden(ev: CustomEvent): void;
+    announce(message: string): void;
+    renderButtonText(): any;
+    renderOverflowCount(): any;
+    handleClearSelection(): void;
+    renderClearSelectionButton(): any;
+    renderSelectionCount(optgroupEl: HTMLWmOptgroupElement): any;
+    render(): any;
+}