@watermarkinsights/ripple 0.0.0-1 → 0.0.1

package/dist/types/components/charts/priv-chart-popover/priv-chart-popover.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+import { SliceDetails } from "../../../global/interfaces";
+export declare class ChartPopover {
+    el: HTMLPrivChartPopoverElement;
+    private chartEl;
+    private liveRegion?;
+    wmChartPopoverButtonTriggered: EventEmitter<HTMLWmChartSliceElement>;
+    wmProgressIndicatorButtonTriggered: EventEmitter<HTMLWmProgressSliceElement>;
+    get eventToEmit(): EventEmitter<HTMLWmChartSliceElement>;
+    intChartPopoverOpenChanged: EventEmitter<boolean>;
+    open: boolean;
+    sliceDetails?: SliceDetails;
+    private popoverWidth;
+    private popoverClicked;
+    handleClickOnDocument(ev: MouseEvent): void;
+    handleClick(ev: MouseEvent): void;
+    componentDidLoad(): void;
+    debouncedClosePopover: (this: any) => void;
+    handleOpenChange(): void;
+    handleDetailsChange(): void;
+    updateHighlightedInfo(): void;
+    handleButtonClick(): void;
+    renderLiveRegion(): void;
+    positionPopover(): void;
+    render(): any;
+}

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

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

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

@@ -0,0 +1,44 @@
+import { ChartType, SliceDetails, SliceElement } from "../../../global/interfaces";
+export declare class Chart {
+    el: HTMLWmChartElement;
+    private componentWrapperEl;
+    chartType: ChartType;
+    label?: string;
+    labelWidth: string;
+    subinfo?: string;
+    valueFormat: "percentage" | "amount" | "none";
+    showGrid?: boolean;
+    showLegend: boolean;
+    showBarLegend: boolean;
+    notStartedColor: boolean;
+    printMode: boolean;
+    printModeFormat: "percentage" | "amount";
+    labelPosition: "left" | "top" | "none";
+    isTabbing: boolean;
+    userIsNavigating: boolean;
+    focusedSliceId?: string;
+    private uid;
+    private total;
+    private slicesDetails;
+    get popoverEl(): HTMLPrivChartPopoverElement | null;
+    get sliceEls(): SliceElement[];
+    get currentChartType(): ChartType;
+    get chartDetails(): import("../../../global/interfaces").ChartDetails;
+    get ariaLabelText(): string;
+    get isDoughnut(): boolean;
+    get isStackedBar(): boolean;
+    get isSimpleBar(): boolean;
+    get isBar(): boolean;
+    toggleTabbingOn(): void;
+    toggleTabbingOff(): void;
+    handleKeydown(ev: KeyboardEvent): void;
+    showHiddenValuesMessage(showMsg: boolean): void;
+    componentWillLoad(): Promise<void>;
+    debouncedSliceUpdate: (this: any) => void;
+    handleSliceUpdate(): void;
+    handlePopoverOpenChanged(ev: CustomEvent): void;
+    renderBarText(s: SliceDetails, minimumWidth: number): any;
+    drawAxis(): any;
+    renderChart(): any;
+    render(): any;
+}

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

@@ -0,0 +1,77 @@
+import { DataPointDetails, Line, LineChartData } 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;
+    lineData: string;
+    units: string;
+    labelWidth: string;
+    highlightQualifier: string;
+    highlightStart?: string;
+    highlightEnd?: string;
+    visibilityToggles: boolean;
+    showDeltas: boolean;
+    yRange?: string;
+    parsedLineData: LineChartData;
+    popoverIndex: number;
+    focusedLine: number;
+    hiddenLines: number[];
+    isTabbing: boolean;
+    intervalSkip: number;
+    announcement: string;
+    private minTickWidth;
+    private popoverData;
+    private dataPointMatrix;
+    private xIntervals;
+    private displayedXIntervals;
+    private yIntervals;
+    private lineStyles;
+    parseData(): void;
+    handleIntervalSkip(): 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;
+    calcYIntervals(): number[];
+    determineDisplayedXIntervals(): any[];
+    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;
+    renderHoverAreas(): any;
+    renderPopover(): any;
+    renderPopoverTable(): any;
+    renderDeltas(dataPoint: DataPointDetails, prevDataPoint: DataPointDetails): any;
+    renderHoverIndicator(): 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(): HTMLPrivChartPopoverElement | 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,77 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class PrivCalendar {
+    el: HTMLPrivCalendarElement;
+    private prevBtnEl;
+    private today;
+    disabled: boolean;
+    view: string;
+    focusDate: string;
+    startDate?: string;
+    endDate?: string;
+    hoverDate?: 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;
+    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;
+    renderCalendarDate: (date: string, index: number, eitherStart?: string, eitherEnd?: string) => any;
+    renderMonth(month: string, index: number): 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 labelEl;
+    private toggleEl;
+    private popupEl;
+    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 openUp;
+    private calWidth;
+    availSpace: number;
+    private hiddenOverflowParent?;
+    private popupClicked;
+    private toggleButtonClicked;
+    isExpanded: boolean;
+    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;
+    togglePopup(): void;
+    closePopup(returnFocus?: boolean): void;
+    openPopup(): void;
+    handleFocus(): void;
+    handleBlur(): void;
+    handleStartInputBlur(): void;
+    handleEndInputBlur(): void;
+    handleStartInput(ev: Event): void;
+    handleEndInput(ev: Event): void;
+    handleKey(ev: KeyboardEvent): void;
+    blurHandler(): void;
+    handleBlurOnWindow(): 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;
+    setAvailSpace(): void;
+    componentWillLoad(): void;
+    announce(message: string): void;
+    renderCalendars(): any;
+    render(): any;
+}

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

@@ -0,0 +1,49 @@
+import { EventEmitter } from "../../stencil-public-runtime";
+export declare class DatePicker {
+    el: HTMLWmDatepickerElement;
+    private liveRegionEl;
+    private dpWrapperEl;
+    private labelWrapperEl;
+    private inputEl;
+    private calEl;
+    private toggleEl;
+    private popupEl;
+    value?: string;
+    disabled: boolean;
+    dateFormat: string;
+    errorMessage?: string;
+    labelPosition: "top" | "left" | "none";
+    label: string;
+    requiredField: boolean;
+    preselected?: string;
+    wmDatepickerDateSelected: EventEmitter;
+    wmDatepickerInputBlurred: EventEmitter;
+    private openUp;
+    private popupClicked;
+    private toggleButtonClicked;
+    isExpanded: boolean;
+    get isDisabled(): boolean;
+    get calendarDate(): string;
+    handleDisabledChange(): void;
+    updateValue(): void;
+    announceError(): void;
+    togglePopup(): void;
+    closePopup(returnFocus?: boolean): void;
+    openPopup(): void;
+    handleInput(ev: Event): void;
+    handleInputBlur(): void;
+    handleInputFocus(): void;
+    handleInputChange(): void;
+    handleKey(ev: KeyboardEvent): void;
+    blurHandler(): void;
+    handleBlurOnWindow(): 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;
+    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,61 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class NestedSelect {
+    el: HTMLWmNestedSelectElement;
+    private buttonEl;
+    private dropdownEl;
+    private menuEl;
+    private optListWrapperEl;
+    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;
+    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;
+    handleOptgroupExpanded(): void;
+    handleOptgroupHidden(ev: CustomEvent): void;
+    announce(message: string): void;
+    renderButtonText(): any;
+    renderOverflowCount(): any;
+    handleClearSelection(): void;
+    renderClearSelectionButton(): any;
+    renderSelectionCount(optgroupEl: HTMLWmOptgroupElement): any;
+    render(): any;
+}

package/dist/types/components/selects/wm-optgroup/wm-optgroup.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class Optgroup {
+    el: HTMLWmOptgroupElement;
+    private optionListEl;
+    label: string;
+    isExpanded: boolean;
+    multiple: boolean;
+    disabled: boolean;
+    wmOptgroupAllSelected: EventEmitter;
+    wmOptgroupAllDeselected: EventEmitter;
+    optgroupExpanded: EventEmitter;
+    optgroupHidden: EventEmitter;
+    get parentNestedSelect(): HTMLWmNestedSelectElement;
+    get isDisabled(): boolean;
+    isExpandedChanged(): void;
+    emitDeselection(): Promise<void>;
+    handleChildChange(): Promise<void>;
+    handleOptionKeyLeft(): void;
+    componentWillLoad(): void;
+    render(): any;
+}

package/dist/types/components/selects/wm-option/wm-option.d.ts

@@ -0,0 +1,40 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class Option {
+    el: HTMLElement;
+    value?: string | null;
+    subinfo?: string;
+    disabled: boolean;
+    selected: boolean;
+    focused: boolean;
+    wmOptionSelected: EventEmitter<HTMLWmOptionElement>;
+    wmOptionDeselected: EventEmitter<HTMLWmOptionElement>;
+    intCloneClicked: EventEmitter<HTMLWmOptionElement>;
+    wmKeyUpPressed: EventEmitter<HTMLWmOptionElement>;
+    wmKeyDownPressed: EventEmitter<HTMLWmOptionElement>;
+    wmKeyLeftPressed: EventEmitter;
+    wmEscKeyPressed: EventEmitter<HTMLWmOptionElement>;
+    wmHomeKeyPressed: EventEmitter<HTMLWmOptionElement>;
+    wmEndKeyPressed: EventEmitter<HTMLWmOptionElement>;
+    wmEnterKeyPressed: EventEmitter<HTMLWmOptionElement>;
+    wmLetterPressed: EventEmitter<{
+        optionEl: HTMLElement;
+        letter: string;
+    }>;
+    wmOptionBlurred: EventEmitter<{
+        relatedTarget: EventTarget | null;
+    }>;
+    private onClickFunc;
+    searchTerm: string;
+    private textEl;
+    get hostClasses(): string;
+    get parentOptionList(): HTMLPrivOptionListElement;
+    handleKeydown(ev: KeyboardEvent): void;
+    handleSelection(): void;
+    handleBlur(ev: FocusEvent): void;
+    syncAriaSelected(): void;
+    syncAriaDisabled(): void;
+    updateDisabledOnClick(): void;
+    handleSearch(ev: CustomEvent): void;
+    componentWillLoad(): void;
+    render(): any;
+}

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

@@ -0,0 +1,55 @@
+import { EventEmitter } from "../../../stencil-public-runtime";
+export declare class Select {
+    el: HTMLWmSelectElement;
+    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;
+    announcement: string;
+    wmSelectDidLoad: EventEmitter<void>;
+    wmSelectBlurred: EventEmitter<void>;
+    wmSelectAllSelected: EventEmitter;
+    wmSelectAllDeselected: EventEmitter;
+    private buttonEl;
+    private labelEl;
+    private dropdownEl;
+    private optionListEl;
+    private liveRegionEl;
+    private measurementAreaEl;
+    private openUp;
+    get childOptions(): HTMLWmOptionElement[];
+    get isDisabled(): boolean;
+    private overflowCount;
+    get selectedOptions(): HTMLWmOptionElement[];
+    private displayedOptions;
+    get allSelected(): boolean;
+    handleOptionSelection(): void;
+    handleChildEnter(): void;
+    closePopupOnEscape(): void;
+    handleOptionBlur(ev: CustomEvent): void;
+    handleClick(ev: MouseEvent): void;
+    handleButtonBlur(ev: FocusEvent): void;
+    handleKey(ev: KeyboardEvent): void;
+    componentWillLoad(): void;
+    handleChildChange(): void;
+    componentDidLoad(): void;
+    open(optionToSelect?: "next" | "previous"): void;
+    close(returnFocus?: boolean): void;
+    announceError(): void;
+    handleDisabledChange(): void;
+    handleComponentBlur(ev: FocusEvent): void;
+    setButtonText(): void;
+    announce(message: string): void;
+    renderButtonText(): any;
+    renderOverflowCount(): any;
+    render(): any;
+}