@vonage/vivid 3.0.0-next.11 → 3.0.0-next.110

package/shared/index2.js

@@ -1,21 +1,9 @@
-import { F as FoundationElement, h as html, d as designSystem } from './index.js';
-import { s as styleInject } from './style-inject.es.js';
+import './es.promise.resolve.js';
+import './index.js';
 
-class Focus extends FoundationElement {}
+const loadComponentsModules = (components, prefix) => {
+  components.forEach(component => import(`../${component}/index.js?prefix=${prefix}`));
+  return Promise.all(components.map(component => customElements.whenDefined(`${prefix}-${component}`)));
+};
 
-var css_248z = ":host {\n  display: contents;\n  border-radius: inherit;\n}\n\n.control {\n  position: absolute;\n  box-sizing: border-box;\n  border-radius: inherit;\n  box-shadow: inset 0 0 0 2px var(--focus-stroke-color, var(--vvd-color-on-canvas)), inset 0 0 0 3px var(--focus-stroke-gap-color, currentColor);\n  inset: 0;\n}";
-styleInject(css_248z);
-
-let _ = t => t,
-    _t;
-const focusTemplate = () => html(_t || (_t = _`
-        <span class="control"></span>`));
-
-const VIVIDFocus = Focus.compose({
-  baseName: 'focus',
-  template: focusTemplate,
-  styles: css_248z
-});
-designSystem.register(VIVIDFocus());
-
-export { Focus as F, VIVIDFocus as V };
+export { loadComponentsModules as l };

package/shared/key-codes.js

@@ -0,0 +1,97 @@
+/**
+ * Key Code values
+ * @deprecated - KeyCodes are deprecated, use individual string key exports
+ */
+var KeyCodes;
+(function (KeyCodes) {
+    KeyCodes[KeyCodes["alt"] = 18] = "alt";
+    KeyCodes[KeyCodes["arrowDown"] = 40] = "arrowDown";
+    KeyCodes[KeyCodes["arrowLeft"] = 37] = "arrowLeft";
+    KeyCodes[KeyCodes["arrowRight"] = 39] = "arrowRight";
+    KeyCodes[KeyCodes["arrowUp"] = 38] = "arrowUp";
+    KeyCodes[KeyCodes["back"] = 8] = "back";
+    KeyCodes[KeyCodes["backSlash"] = 220] = "backSlash";
+    KeyCodes[KeyCodes["break"] = 19] = "break";
+    KeyCodes[KeyCodes["capsLock"] = 20] = "capsLock";
+    KeyCodes[KeyCodes["closeBracket"] = 221] = "closeBracket";
+    KeyCodes[KeyCodes["colon"] = 186] = "colon";
+    KeyCodes[KeyCodes["colon2"] = 59] = "colon2";
+    KeyCodes[KeyCodes["comma"] = 188] = "comma";
+    KeyCodes[KeyCodes["ctrl"] = 17] = "ctrl";
+    KeyCodes[KeyCodes["delete"] = 46] = "delete";
+    KeyCodes[KeyCodes["end"] = 35] = "end";
+    KeyCodes[KeyCodes["enter"] = 13] = "enter";
+    KeyCodes[KeyCodes["equals"] = 187] = "equals";
+    KeyCodes[KeyCodes["equals2"] = 61] = "equals2";
+    KeyCodes[KeyCodes["equals3"] = 107] = "equals3";
+    KeyCodes[KeyCodes["escape"] = 27] = "escape";
+    KeyCodes[KeyCodes["forwardSlash"] = 191] = "forwardSlash";
+    KeyCodes[KeyCodes["function1"] = 112] = "function1";
+    KeyCodes[KeyCodes["function10"] = 121] = "function10";
+    KeyCodes[KeyCodes["function11"] = 122] = "function11";
+    KeyCodes[KeyCodes["function12"] = 123] = "function12";
+    KeyCodes[KeyCodes["function2"] = 113] = "function2";
+    KeyCodes[KeyCodes["function3"] = 114] = "function3";
+    KeyCodes[KeyCodes["function4"] = 115] = "function4";
+    KeyCodes[KeyCodes["function5"] = 116] = "function5";
+    KeyCodes[KeyCodes["function6"] = 117] = "function6";
+    KeyCodes[KeyCodes["function7"] = 118] = "function7";
+    KeyCodes[KeyCodes["function8"] = 119] = "function8";
+    KeyCodes[KeyCodes["function9"] = 120] = "function9";
+    KeyCodes[KeyCodes["home"] = 36] = "home";
+    KeyCodes[KeyCodes["insert"] = 45] = "insert";
+    KeyCodes[KeyCodes["menu"] = 93] = "menu";
+    KeyCodes[KeyCodes["minus"] = 189] = "minus";
+    KeyCodes[KeyCodes["minus2"] = 109] = "minus2";
+    KeyCodes[KeyCodes["numLock"] = 144] = "numLock";
+    KeyCodes[KeyCodes["numPad0"] = 96] = "numPad0";
+    KeyCodes[KeyCodes["numPad1"] = 97] = "numPad1";
+    KeyCodes[KeyCodes["numPad2"] = 98] = "numPad2";
+    KeyCodes[KeyCodes["numPad3"] = 99] = "numPad3";
+    KeyCodes[KeyCodes["numPad4"] = 100] = "numPad4";
+    KeyCodes[KeyCodes["numPad5"] = 101] = "numPad5";
+    KeyCodes[KeyCodes["numPad6"] = 102] = "numPad6";
+    KeyCodes[KeyCodes["numPad7"] = 103] = "numPad7";
+    KeyCodes[KeyCodes["numPad8"] = 104] = "numPad8";
+    KeyCodes[KeyCodes["numPad9"] = 105] = "numPad9";
+    KeyCodes[KeyCodes["numPadDivide"] = 111] = "numPadDivide";
+    KeyCodes[KeyCodes["numPadDot"] = 110] = "numPadDot";
+    KeyCodes[KeyCodes["numPadMinus"] = 109] = "numPadMinus";
+    KeyCodes[KeyCodes["numPadMultiply"] = 106] = "numPadMultiply";
+    KeyCodes[KeyCodes["numPadPlus"] = 107] = "numPadPlus";
+    KeyCodes[KeyCodes["openBracket"] = 219] = "openBracket";
+    KeyCodes[KeyCodes["pageDown"] = 34] = "pageDown";
+    KeyCodes[KeyCodes["pageUp"] = 33] = "pageUp";
+    KeyCodes[KeyCodes["period"] = 190] = "period";
+    KeyCodes[KeyCodes["print"] = 44] = "print";
+    KeyCodes[KeyCodes["quote"] = 222] = "quote";
+    KeyCodes[KeyCodes["scrollLock"] = 145] = "scrollLock";
+    KeyCodes[KeyCodes["shift"] = 16] = "shift";
+    KeyCodes[KeyCodes["space"] = 32] = "space";
+    KeyCodes[KeyCodes["tab"] = 9] = "tab";
+    KeyCodes[KeyCodes["tilde"] = 192] = "tilde";
+    KeyCodes[KeyCodes["windowsLeft"] = 91] = "windowsLeft";
+    KeyCodes[KeyCodes["windowsOpera"] = 219] = "windowsOpera";
+    KeyCodes[KeyCodes["windowsRight"] = 92] = "windowsRight";
+})(KeyCodes || (KeyCodes = {}));
+/**
+ * String values for use with KeyboardEvent.key
+ */
+const keyArrowDown = "ArrowDown";
+const keyArrowLeft = "ArrowLeft";
+const keyArrowRight = "ArrowRight";
+const keyArrowUp = "ArrowUp";
+const keyEnter = "Enter";
+const keyEscape = "Escape";
+const keyHome = "Home";
+const keyEnd = "End";
+const keySpace = " ";
+const keyTab = "Tab";
+const ArrowKeys = {
+    ArrowDown: keyArrowDown,
+    ArrowLeft: keyArrowLeft,
+    ArrowRight: keyArrowRight,
+    ArrowUp: keyArrowUp,
+};
+
+export { ArrowKeys as A, keySpace as a, keyEscape as b, keyTab as c, keyEnd as d, keyArrowUp as e, keyArrowDown as f, keyHome as g, keyArrowLeft as h, keyArrowRight as i, keyEnter as k };

package/shared/listbox-option.js

@@ -0,0 +1,201 @@
+import { F as FoundationElement, Z as Observable, _ as __decorate, V as observable, a as attr } from './index.js';
+import { A as ARIAGlobalStatesAndProperties } from './aria-global.js';
+import { S as StartEnd } from './start-end.js';
+import { a as applyMixins } from './apply-mixins.js';
+import { i as isHTMLElement } from './dom.js';
+
+/**
+ * Determines if the element is a {@link (ListboxOption:class)}
+ *
+ * @param element - the element to test.
+ * @public
+ */
+function isListboxOption(el) {
+    return (isHTMLElement(el) &&
+        (el.getAttribute("role") === "option" ||
+            el instanceof HTMLOptionElement));
+}
+/**
+ * An Option Custom HTML Element.
+ * Implements {@link https://www.w3.org/TR/wai-aria-1.1/#option | ARIA option }.
+ *
+ * @slot start - Content which can be provided before the listbox option content
+ * @slot end - Content which can be provided after the listbox option content
+ * @slot - The default slot for listbox option content
+ * @csspart content - Wraps the listbox option content
+ *
+ * @public
+ */
+class ListboxOption extends FoundationElement {
+    constructor(text, value, defaultSelected, selected) {
+        super();
+        /**
+         * The defaultSelected state of the option.
+         * @public
+         */
+        this.defaultSelected = false;
+        /**
+         * Tracks whether the "selected" property has been changed.
+         * @internal
+         */
+        this.dirtySelected = false;
+        /**
+         * The checked state of the control.
+         *
+         * @public
+         */
+        this.selected = this.defaultSelected;
+        /**
+         * Track whether the value has been changed from the initial value
+         */
+        this.dirtyValue = false;
+        if (text) {
+            this.textContent = text;
+        }
+        if (value) {
+            this.initialValue = value;
+        }
+        if (defaultSelected) {
+            this.defaultSelected = defaultSelected;
+        }
+        if (selected) {
+            this.selected = selected;
+        }
+        this.proxy = new Option(`${this.textContent}`, this.initialValue, this.defaultSelected, this.selected);
+        this.proxy.disabled = this.disabled;
+    }
+    /**
+     * Updates the ariaChecked property when the checked property changes.
+     *
+     * @param prev - the previous checked value
+     * @param next - the current checked value
+     *
+     * @public
+     */
+    checkedChanged(prev, next) {
+        if (typeof next === "boolean") {
+            this.ariaChecked = next ? "true" : "false";
+            return;
+        }
+        this.ariaChecked = null;
+    }
+    /**
+     * Updates the proxy's text content when the default slot changes.
+     * @param prev - the previous content value
+     * @param next - the current content value
+     *
+     * @internal
+     */
+    contentChanged(prev, next) {
+        if (this.proxy instanceof HTMLOptionElement) {
+            this.proxy.textContent = this.textContent;
+        }
+        this.$emit("contentchange", null, { bubbles: true });
+    }
+    defaultSelectedChanged() {
+        if (!this.dirtySelected) {
+            this.selected = this.defaultSelected;
+            if (this.proxy instanceof HTMLOptionElement) {
+                this.proxy.selected = this.defaultSelected;
+            }
+        }
+    }
+    disabledChanged(prev, next) {
+        this.ariaDisabled = this.disabled ? "true" : "false";
+        if (this.proxy instanceof HTMLOptionElement) {
+            this.proxy.disabled = this.disabled;
+        }
+    }
+    selectedAttributeChanged() {
+        this.defaultSelected = this.selectedAttribute;
+        if (this.proxy instanceof HTMLOptionElement) {
+            this.proxy.defaultSelected = this.defaultSelected;
+        }
+    }
+    selectedChanged() {
+        this.ariaSelected = this.selected ? "true" : "false";
+        if (!this.dirtySelected) {
+            this.dirtySelected = true;
+        }
+        if (this.proxy instanceof HTMLOptionElement) {
+            this.proxy.selected = this.selected;
+        }
+    }
+    initialValueChanged(previous, next) {
+        // If the value is clean and the component is connected to the DOM
+        // then set value equal to the attribute value.
+        if (!this.dirtyValue) {
+            this.value = this.initialValue;
+            this.dirtyValue = false;
+        }
+    }
+    get label() {
+        var _a;
+        return (_a = this.value) !== null && _a !== void 0 ? _a : this.text;
+    }
+    get text() {
+        var _a, _b;
+        return (_b = (_a = this.textContent) === null || _a === void 0 ? void 0 : _a.replace(/\s+/g, " ").trim()) !== null && _b !== void 0 ? _b : "";
+    }
+    set value(next) {
+        const newValue = `${next !== null && next !== void 0 ? next : ""}`;
+        this._value = newValue;
+        this.dirtyValue = true;
+        if (this.proxy instanceof HTMLOptionElement) {
+            this.proxy.value = newValue;
+        }
+        Observable.notify(this, "value");
+    }
+    get value() {
+        var _a;
+        Observable.track(this, "value");
+        return (_a = this._value) !== null && _a !== void 0 ? _a : this.text;
+    }
+    get form() {
+        return this.proxy ? this.proxy.form : null;
+    }
+}
+__decorate([
+    observable
+], ListboxOption.prototype, "checked", void 0);
+__decorate([
+    observable
+], ListboxOption.prototype, "content", void 0);
+__decorate([
+    observable
+], ListboxOption.prototype, "defaultSelected", void 0);
+__decorate([
+    attr({ mode: "boolean" })
+], ListboxOption.prototype, "disabled", void 0);
+__decorate([
+    attr({ attribute: "selected", mode: "boolean" })
+], ListboxOption.prototype, "selectedAttribute", void 0);
+__decorate([
+    observable
+], ListboxOption.prototype, "selected", void 0);
+__decorate([
+    attr({ attribute: "value", mode: "fromView" })
+], ListboxOption.prototype, "initialValue", void 0);
+/**
+ * States and properties relating to the ARIA `option` role.
+ *
+ * @public
+ */
+class DelegatesARIAListboxOption {
+}
+__decorate([
+    observable
+], DelegatesARIAListboxOption.prototype, "ariaChecked", void 0);
+__decorate([
+    observable
+], DelegatesARIAListboxOption.prototype, "ariaPosInSet", void 0);
+__decorate([
+    observable
+], DelegatesARIAListboxOption.prototype, "ariaSelected", void 0);
+__decorate([
+    observable
+], DelegatesARIAListboxOption.prototype, "ariaSetSize", void 0);
+applyMixins(DelegatesARIAListboxOption, ARIAGlobalStatesAndProperties);
+applyMixins(ListboxOption, StartEnd, DelegatesARIAListboxOption);
+
+export { ListboxOption as L, isListboxOption as i };

package/shared/menu-item.js

@@ -0,0 +1,277 @@
+import { F as FoundationElement, a2 as DOM, _ as __decorate, a as attr, V as observable } from './index.js';
+import { S as StartEnd } from './start-end.js';
+import { D as Direction, g as getDirection } from './direction.js';
+import { a as applyMixins } from './apply-mixins.js';
+import { h as keyArrowLeft, i as keyArrowRight, a as keySpace, k as keyEnter } from './key-codes.js';
+
+/**
+ * Menu items roles.
+ * @public
+ */
+const MenuItemRole = {
+    /**
+     * The menu item has a "menuitem" role
+     */
+    menuitem: "menuitem",
+    /**
+     * The menu item has a "menuitemcheckbox" role
+     */
+    menuitemcheckbox: "menuitemcheckbox",
+    /**
+     * The menu item has a "menuitemradio" role
+     */
+    menuitemradio: "menuitemradio",
+};
+/**
+ * @internal
+ */
+const roleForMenuItem = {
+    [MenuItemRole.menuitem]: "menuitem",
+    [MenuItemRole.menuitemcheckbox]: "menuitemcheckbox",
+    [MenuItemRole.menuitemradio]: "menuitemradio",
+};
+
+/**
+ * A Switch Custom HTML Element.
+ * Implements {@link https://www.w3.org/TR/wai-aria-1.1/#menuitem | ARIA menuitem }, {@link https://www.w3.org/TR/wai-aria-1.1/#menuitemcheckbox | ARIA menuitemcheckbox}, or {@link https://www.w3.org/TR/wai-aria-1.1/#menuitemradio | ARIA menuitemradio }.
+ *
+ * @slot checked-indicator - The checked indicator
+ * @slot radio-indicator - The radio indicator
+ * @slot start - Content which can be provided before the menu item content
+ * @slot end - Content which can be provided after the menu item content
+ * @slot - The default slot for menu item content
+ * @slot expand-collapse-indicator - The expand/collapse indicator
+ * @slot submenu - Used to nest menu's within menu items
+ * @csspart input-container - The element representing the visual checked or radio indicator
+ * @csspart checkbox - The element wrapping the `menuitemcheckbox` indicator
+ * @csspart radio - The element wrapping the `menuitemradio` indicator
+ * @csspart content - The element wrapping the menu item content
+ * @csspart expand-collapse-glyph-container - The element wrapping the expand collapse element
+ * @csspart expand-collapse - The expand/collapse element
+ * @csspart submenu-region - The container for the submenu, used for positioning
+ * @fires expanded-change - Fires a custom 'expanded-change' event when the expanded state changes
+ * @fires change - Fires a custom 'change' event when a non-submenu item with a role of `menuitemcheckbox`, `menuitemradio`, or `menuitem` is invoked
+ *
+ * @public
+ */
+class MenuItem extends FoundationElement {
+    constructor() {
+        super(...arguments);
+        /**
+         * The role of the element.
+         *
+         * @public
+         * @remarks
+         * HTML Attribute: role
+         */
+        this.role = MenuItemRole.menuitem;
+        /**
+         * @internal
+         */
+        this.hasSubmenu = false;
+        /**
+         * Track current direction to pass to the anchored region
+         *
+         * @internal
+         */
+        this.currentDirection = Direction.ltr;
+        this.focusSubmenuOnLoad = false;
+        /**
+         * @internal
+         */
+        this.handleMenuItemKeyDown = (e) => {
+            if (e.defaultPrevented) {
+                return false;
+            }
+            switch (e.key) {
+                case keyEnter:
+                case keySpace:
+                    this.invoke();
+                    return false;
+                case keyArrowRight:
+                    //open/focus on submenu
+                    this.expandAndFocus();
+                    return false;
+                case keyArrowLeft:
+                    //close submenu
+                    if (this.expanded) {
+                        this.expanded = false;
+                        this.focus();
+                        return false;
+                    }
+            }
+            return true;
+        };
+        /**
+         * @internal
+         */
+        this.handleMenuItemClick = (e) => {
+            if (e.defaultPrevented || this.disabled) {
+                return false;
+            }
+            this.invoke();
+            return false;
+        };
+        /**
+         * @internal
+         */
+        this.submenuLoaded = () => {
+            if (!this.focusSubmenuOnLoad) {
+                return;
+            }
+            this.focusSubmenuOnLoad = false;
+            if (this.hasSubmenu) {
+                this.submenu.focus();
+                this.setAttribute("tabindex", "-1");
+            }
+        };
+        /**
+         * @internal
+         */
+        this.handleMouseOver = (e) => {
+            if (this.disabled || !this.hasSubmenu || this.expanded) {
+                return false;
+            }
+            this.expanded = true;
+            return false;
+        };
+        /**
+         * @internal
+         */
+        this.handleMouseOut = (e) => {
+            if (!this.expanded || this.contains(document.activeElement)) {
+                return false;
+            }
+            this.expanded = false;
+            return false;
+        };
+        /**
+         * @internal
+         */
+        this.expandAndFocus = () => {
+            if (!this.hasSubmenu) {
+                return;
+            }
+            this.focusSubmenuOnLoad = true;
+            this.expanded = true;
+        };
+        /**
+         * @internal
+         */
+        this.invoke = () => {
+            if (this.disabled) {
+                return;
+            }
+            switch (this.role) {
+                case MenuItemRole.menuitemcheckbox:
+                    this.checked = !this.checked;
+                    break;
+                case MenuItemRole.menuitem:
+                    // update submenu
+                    this.updateSubmenu();
+                    if (this.hasSubmenu) {
+                        this.expandAndFocus();
+                    }
+                    else {
+                        this.$emit("change");
+                    }
+                    break;
+                case MenuItemRole.menuitemradio:
+                    if (!this.checked) {
+                        this.checked = true;
+                    }
+                    break;
+            }
+        };
+        /**
+         * Gets the submenu element if any
+         *
+         * @internal
+         */
+        this.updateSubmenu = () => {
+            this.submenu = this.domChildren().find((element) => {
+                return element.getAttribute("role") === "menu";
+            });
+            this.hasSubmenu = this.submenu === undefined ? false : true;
+        };
+    }
+    expandedChanged(oldValue) {
+        if (this.$fastController.isConnected) {
+            if (this.submenu === undefined) {
+                return;
+            }
+            if (this.expanded === false) {
+                this.submenu.collapseExpandedItem();
+            }
+            else {
+                this.currentDirection = getDirection(this);
+            }
+            this.$emit("expanded-change", this, { bubbles: false });
+        }
+    }
+    checkedChanged(oldValue, newValue) {
+        if (this.$fastController.isConnected) {
+            this.$emit("change");
+        }
+    }
+    /**
+     * @internal
+     */
+    connectedCallback() {
+        super.connectedCallback();
+        DOM.queueUpdate(() => {
+            this.updateSubmenu();
+        });
+        if (!this.startColumnCount) {
+            this.startColumnCount = 1;
+        }
+        this.observer = new MutationObserver(this.updateSubmenu);
+    }
+    /**
+     * @internal
+     */
+    disconnectedCallback() {
+        super.disconnectedCallback();
+        this.submenu = undefined;
+        if (this.observer !== undefined) {
+            this.observer.disconnect();
+            this.observer = undefined;
+        }
+    }
+    /**
+     * get an array of valid DOM children
+     */
+    domChildren() {
+        return Array.from(this.children).filter(child => !child.hasAttribute("hidden"));
+    }
+}
+__decorate([
+    attr({ mode: "boolean" })
+], MenuItem.prototype, "disabled", void 0);
+__decorate([
+    attr({ mode: "boolean" })
+], MenuItem.prototype, "expanded", void 0);
+__decorate([
+    observable
+], MenuItem.prototype, "startColumnCount", void 0);
+__decorate([
+    attr
+], MenuItem.prototype, "role", void 0);
+__decorate([
+    attr({ mode: "boolean" })
+], MenuItem.prototype, "checked", void 0);
+__decorate([
+    observable
+], MenuItem.prototype, "submenuRegion", void 0);
+__decorate([
+    observable
+], MenuItem.prototype, "hasSubmenu", void 0);
+__decorate([
+    observable
+], MenuItem.prototype, "currentDirection", void 0);
+__decorate([
+    observable
+], MenuItem.prototype, "submenu", void 0);
+applyMixins(MenuItem, StartEnd);
+
+export { MenuItem as M, MenuItemRole as a, roleForMenuItem as r };

package/shared/numbers.js

@@ -0,0 +1,25 @@
+/**
+ * This method keeps a given value within the bounds of a min and max value. If the value
+ * is larger than the max, the minimum value will be returned. If the value is smaller than the minimum,
+ * the maximum will be returned. Otherwise, the value is returned un-changed.
+ */
+/**
+ * Ensures that a value is between a min and max value. If value is lower than min, min will be returned.
+ * If value is greater than max, max will be returned.
+ */
+function limit(min, max, value) {
+    return Math.min(Math.max(value, min), max);
+}
+/**
+ * Determines if a number value is within a specified range.
+ *
+ * @param value - the value to check
+ * @param min - the range start
+ * @param max - the range end
+ */
+function inRange(value, min, max = 0) {
+    [min, max] = [min, max].sort((a, b) => a - b);
+    return min <= value && value < max;
+}
+
+export { inRange as i, limit as l };

package/shared/patterns/focus.d.ts

@@ -0,0 +1,3 @@
+import type { ViewTemplate } from '@microsoft/fast-element';
+import type { ElementDefinitionContext } from '@microsoft/fast-foundation';
+export declare const focusTemplateFactory: (context: ElementDefinitionContext) => ViewTemplate | null;

package/shared/patterns/form-elements/form-elements.d.ts

@@ -0,0 +1,31 @@
+import type { ElementDefinitionContext } from '@microsoft/fast-foundation';
+export interface FormElement {
+    charCount: boolean;
+    errorValidationMessage: boolean;
+    helperText: string;
+    successText: string;
+    label: string;
+    userValid: boolean;
+    dirtyValue: boolean;
+}
+export declare function formElements<T extends {
+    new (...args: any[]): Record<string, any>;
+}>(constructor: T): {
+    new (...args: any[]): {
+        [x: string]: any;
+        label?: string | undefined;
+        helperText?: string | undefined;
+        successText?: string | undefined;
+        charCount: boolean;
+        userValid: boolean;
+        "__#7248@#blurred": boolean;
+        readonly errorValidationMessage: any;
+        connectedCallback(): void;
+        "__#7248@#handleInvalidEvent": () => void;
+        disconnectedCallback(): void;
+        validate: () => void;
+    };
+} & T;
+declare type FeedbackType = 'error' | 'helper' | 'success';
+export declare function getFeedbackTemplate(messageType: FeedbackType, context: ElementDefinitionContext): import("@microsoft/fast-element").ViewTemplate<FormElement, any>;
+export {};

package/shared/patterns/form-elements/index.d.ts

@@ -0,0 +1 @@
+export * from './form-elements';

package/shared/patterns/index.d.ts

@@ -1 +1,3 @@
 export * from './affix';
+export * from './focus';
+export * from './form-elements';