@evance/evance-ui 1.0.12 → 1.0.14

package/dist/types/index.d.ts

@@ -4,9 +4,12 @@ import { Component } from 'vue';
 import { ComponentCustomProperties } from 'vue';
 import { ComponentCustomProps } from 'vue';
 import { ComponentInternalInstance } from 'vue';
+import { ComponentObjectPropsOptions } from 'vue';
+import { ComponentOptions } from 'vue';
 import { ComponentOptionsBase } from 'vue';
 import { ComponentOptionsMixin } from 'vue';
 import { ComponentPublicInstance } from 'vue';
+import { ComputedGetter } from 'vue';
 import { ComputedRef } from 'vue';
 import { DebuggerEvent } from 'vue';
 import { DefineComponent } from 'vue';
@@ -15,9 +18,13 @@ import { EffectScope } from 'vue';
 import { ExtractPropTypes } from 'vue';
 import { FunctionalComponent } from 'vue';
 import { HistoryState } from 'vue-router';
+import { IfAny as IfAny_2 } from '@vue/shared';
 import { InjectionKey } from 'vue';
 import { LocationQueryRaw } from 'vue-router';
+import { MaybeRef } from 'vue';
 import { nextTick } from 'vue';
+import { Plugin as Plugin_2 } from 'vue';
+import { Prop } from 'vue';
 import { PropType } from 'vue';
 import { Ref } from 'vue';
 import { RendererElement } from 'vue';
@@ -29,9 +36,11 @@ import { ShallowRef } from 'vue';
 import { ShallowUnwrapRef } from 'vue';
 import { Slot } from 'vue';
 import { StyleValue } from 'vue';
+import { ToRefs } from 'vue';
 import { TransitionProps } from 'vue';
 import { UnwrapRef } from 'vue';
 import { VNode } from 'vue';
+import { VNodeChild } from 'vue';
 import { VNodeProps } from 'vue';
 import { VNodeRef } from 'vue';
 import { WatchOptions } from 'vue';
@@ -636,6 +645,25 @@ export declare interface ActivatorProps extends DelayOpenCloseProps {
 
 declare type ActivatorSelector = "parent" | string | Element | ComponentPublicInstance;
 
+/**
+ * ## Add Scroll Event Listeners to Element (and its parents)
+ * @param el
+ * @param onScroll
+ */
+export declare function addScrollEventListener(el: HTMLElement | undefined, onScroll: (e: Event) => void): void;
+
+/**
+ * # Adjust Bounding Rect
+ *
+ * Calculate Bounding Rect before being transformed.
+ *
+ * This doesn't account for skew or rotate translations, but at least it produces correct edge positions
+ * when scale is used and does not impose much of a performance penalty when there is no transform.
+ *
+ * @see https://stackoverflow.com/a/57876601/2074736
+ */
+export declare function adjustedBoundingRect(el: HTMLElement): Rect;
+
 export declare type AlignContentObject = {
     [key in DisplayBreakpoint]: AlignContentValue;
 };
@@ -663,7 +691,83 @@ export declare type AlignSelfPropObject = {
 /** Align Self Props */
 export declare type AlignSelfPropValue = "auto" | "start" | "end" | "center" | "baseline" | "stretch";
 
-declare type AnchorSelector = VerticalSide | HorizontalSide | `${VerticalSide}${SelectorSeparator}${EdgeAlignment}` | `${HorizontalSide}${SelectorSeparator}${EdgeAlignment}` | "auto" | `auto${SelectorSeparator}${EdgeAlignment | "auto"}` | "center" | `center${SelectorSeparator}center`;
+/**
+ * # Anchor
+ *
+ * - `alignment`: 'start', 'end', 'center', 'auto'
+ * - `side`: 'top', 'bottom', 'left', 'right', 'center', 'auto'
+ *
+ */
+export declare class Anchor {
+    side: AnchorSide;
+    alignment: AnchorAlignment;
+    constructor(side: AnchorSide, alignment: AnchorAlignment);
+    /**
+     * ## Get Axis
+     * Returns either x or y axis.
+     */
+    get axis(): Axis;
+    /**
+     * ## Physical Alignment
+     */
+    get physicalAlignment(): PhysicalAlignment;
+    /**
+     * ## Center Align
+     */
+    centerAlign(): Anchor;
+    /**
+     * ## Flip Alignment
+     */
+    flipAlignment(): Anchor;
+    /**
+     * ## Flip Corner
+     */
+    flipCorner(): Anchor;
+    /**
+     * ## Flip Side
+     */
+    flipSide(): Anchor;
+    /**
+     * ## Parse Selector
+     * @param selector
+     * @param isRtl
+     * @private
+     */
+    static fromSelector(selector: AnchorSelector, isRtl?: boolean): Anchor;
+    toCssValue(): string;
+    toString(): string;
+}
+
+export declare type AnchorAlignment = EdgeAlignment | "auto";
+
+export declare type AnchorSelector = VerticalSide | HorizontalSide | `${VerticalSide}${SelectorSeparator}${EdgeAlignment}` | `${HorizontalSide}${SelectorSeparator}${EdgeAlignment}` | "auto" | `auto${SelectorSeparator}${EdgeAlignment | "auto"}` | "center" | `center${SelectorSeparator}center`;
+
+export declare type AnchorSide = VerticalSide | HorizontalSide | "auto" | "center";
+
+/**
+ * # Animate
+ *
+ * We take advantage of the Element interface's animate() method.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Element/animate
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Web_Animations_API/Keyframe_Formats
+ *
+ * @param el The element we wish to animate
+ * @param keyframes The keyframes to use during animation (see the Keyframes format)
+ * @param options An integer duration (in milliseconds), OR an Object containing timing properties
+ */
+export declare function animate(el: Element, keyframes: Keyframe[] | PropertyIndexedKeyframes | null, options?: number | KeyframeAnimationOptions): {
+    readonly finished: Promise<void>;
+} | Animation;
+
+/**
+ * ## Animate Finished
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Animation/finished
+ */
+export declare const animateFinished: {
+    readonly finished: Promise<void>;
+};
 
 /**
  * # Appearance
@@ -671,7 +775,7 @@ declare type AnchorSelector = VerticalSide | HorizontalSide | `${VerticalSide}${
  * Default appearance keys for
  *
  */
-declare const Appearance: {
+export declare const Appearance: {
     readonly default: "default";
     readonly danger: "danger";
     readonly information: "information";
@@ -681,12 +785,45 @@ declare const Appearance: {
     readonly warning: "warning";
 };
 
-declare type AppearanceProp = (typeof Appearance)[keyof typeof Appearance];
+/**
+ * ## Make an Appearance Modifier Class Name
+ * @param value
+ * @param exclude
+ */
+export declare function appearanceModifier(value: string, exclude?: (string | RegExp)[]): string | undefined;
+
+export declare type AppearanceProp = (typeof Appearance)[keyof typeof Appearance];
+
+export declare interface AppearanceProps {
+    appearance: AppearanceProp;
+    variant?: VariantProp;
+}
+
+declare type AppendDefault<T extends ComponentObjectPropsOptions, D extends PartialKeys<T>> = {
+    [P in keyof T]-?: unknown extends D[P] ? T[P] : T[P] extends Record<string, unknown> ? Omit<T[P], "type" | "default"> & {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    } : {
+        type: PropType<MergeDefault<T[P], D[P]>>;
+        default: MergeDefault<T[P], D[P]>;
+    };
+};
 
 export declare type AspectRatioProps = {
     aspectRatio?: string | number;
 };
 
+export declare const axes: readonly ["x", "y"];
+
+export declare type Axis = (typeof axes)[number];
+
+/**
+ * # Bind Props
+ * @param el
+ * @param props
+ */
+export declare function bindProps(el: HTMLElement, props: Record<string, any>): void;
+
 /** Block Number Props */
 export declare type BlockNumber = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
 
@@ -730,6 +867,20 @@ declare type Breakpoint = (typeof breakpoints)[number];
  */
 declare const breakpoints: readonly ["sm", "md", "lg", "xl", "xxl"];
 
+/**
+ * # Browser
+ */
+export declare class Browser {
+    static readonly hasWindow: boolean;
+    static readonly supportsIntersection: boolean;
+    /**
+     * ## Supports Touch
+     * Added into a static getter method to avoid issues during development when switching between emulators.
+     */
+    static get supportsTouch(): boolean;
+    static readonly supportsFocusVisible: boolean;
+}
+
 /**
  * ## Button Appearance
  */
@@ -741,10 +892,68 @@ export declare type ButtonToggleSlotProps = "isSelected" | "select" | "selected"
 
 export declare type ButtonVariantProp = VariantProp | "link";
 
+/**
+ * # Call Event
+ * @param eventHandler
+ * @param args
+ */
+export declare function callEvent<T extends any[]>(eventHandler: EventProp<T> | undefined, ...args: T): void;
+
 declare type CellProps<T> = Record<string, any> | ((data: Pick<ItemKeySlot<T>, "index" | "item" | "internalItem" | "value" | "column">) => Record<string, any>);
 
+/**
+ * # Clamp
+ *
+ * @param value
+ * @param min
+ * @param max
+ */
+export declare function clamp(value: number, min?: number, max?: number): number;
+
 declare type ClassValue = any;
 
+/**
+ * # Click Blocked Animation
+ * @param el
+ */
+export declare function clickBlockedAnimation(el: HTMLElement | null | undefined): {
+    readonly finished: Promise<void>;
+} | Animation;
+
+/**
+ * # Click Event Listeners
+ * Standard listeners for click events.
+ */
+export declare interface ClickEventListeners {
+    onClick?: EventProp | undefined;
+    onClickOnce?: EventProp | undefined;
+}
+
+/**
+ * # Click Outside Directive
+ *
+ * There are two handlers:
+ * 1. onClick - handles click events, which are triggered after...
+ * 2. onMouseDown - determines if the mouse was outside before the click event finished.
+ *
+ * This helps us get over an issue we had previously, where mouse dragging during a click
+ * caused dialogs to close unwantedly.
+ */
+export declare const clickOutside: {
+    /**
+     * Add event listeners when the component is mounted.
+     * @param el
+     * @param binding
+     */
+    mounted(el: ClickOutsideHTMLElement, binding: ClickOutsideBinding): void;
+    /**
+     * Remove event listeners when the component is unmounted.
+     * @param el
+     * @param binding
+     */
+    unmounted(el: ClickOutsideHTMLElement, binding: ClickOutsideBinding): void;
+};
+
 /**
  * ## Click Outside Args
  *
@@ -1015,7 +1224,6 @@ declare namespace components {
         EvTextSizeProp,
         EvTextSizeClass,
         FontWeight,
-        TextAppearanceProp,
         EvTextProps,
         makeEvTextProps,
         EvTextarea,
@@ -1060,6 +1268,18 @@ declare function connectedPositionStrategy(data: PositionStrategyData, props: Po
     };
 };
 
+/**
+ * # Console Error
+ * @param message
+ */
+export declare function consoleError(message: string): void;
+
+/**
+ * # Console Warn
+ * @param message
+ */
+export declare function consoleWarn(message: string): void;
+
 declare interface ContentEvents {
     onMouseenter?: () => void;
     onMouseleave?: () => void;
@@ -1072,7 +1292,7 @@ declare interface ContentEvents {
  * # Coordinates
  * Two-dimensional coordinates (x,y).
  */
-declare interface Coordinates {
+export declare interface Coordinates {
     x: number;
     y: number;
 }
@@ -1118,6 +1338,30 @@ export declare const createEvanceUi: (options?: EvanceUiOptions) => {
     };
 };
 
+/**
+ * # Create Range
+ *
+ * @param length
+ * @param start
+ */
+export declare function createRange(length: number, start?: number): number[];
+
+/**
+ * # String Template
+ *
+ * An approximation of Evance's String Templates.
+ *
+ * Allows us to build strings as a template with replacement variables.
+ *
+ * This is inspired by the output tags of EVML and behaves similarly. However, unlike EVML
+ * which is compiled this is a simple find and replace template format and variables are only
+ * wrapped within single curly brackets e.g. 'Hello { name }'.
+ *
+ * @param template
+ * @param defaultVariables
+ */
+export declare function createStringTemplate(template: string, defaultVariables?: TemplateVariables): TemplateFunction;
+
 declare type DataTableCompareFunction<T = any> = (a: T, b: T) => number;
 
 declare type DataTableHeader = {
@@ -1204,6 +1448,21 @@ declare interface DateAdapterInstanceType {
 
 declare type DateOptions<T = any> = Partial<InternalDateOptions<T>>;
 
+/**
+ * ## debounce
+ *
+ * @param fn The function to debounce
+ * @param delay The debounce delay (either a number or a ref of a number)
+ * @returns A debounced version of the function with `clear` and `immediate` methods
+ */
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, delay: MaybeRef<number>): DebouncedFunction<T>;
+
+declare type DebouncedFunction<T extends (...args: any[]) => any> = {
+    (...args: Parameters<T>): void;
+    clear: () => void;
+    immediate: T;
+};
+
 export declare interface DefaultButtonToggleSlot extends Pick<GroupProvide, ButtonToggleSlotProps> {
 }
 
@@ -1219,6 +1478,14 @@ declare interface DelayOpenCloseProps {
     openDelay?: number | string;
 }
 
+/**
+ * # Destruct Computed
+ *
+ * Convert a computed ref to a record of refs.
+ * The getter function must always return an object with the same keys.
+ */
+export declare function destructComputed<T extends object>(getter: ComputedGetter<T & NotAUnion<T>>): ToRefs<T>;
+
 export declare const DialogSize: {
     readonly default: "medium";
     readonly small: "small";
@@ -1234,14 +1501,14 @@ export declare const DialogSizeToWidth: Record<string, number>;
 /**
  * # Dimensions
  */
-declare interface Dimensions {
+export declare interface Dimensions {
     width: number;
     height: number;
 }
 
 declare namespace directives {
     export {
-        vClickOutside,
+        clickOutside,
         ObserverDirectiveBinding,
         Intersect,
         SlotsDirective,
@@ -1350,6 +1617,12 @@ declare interface DividerProps {
     vertical?: boolean;
 }
 
+export declare const easingAccelerate = "cubic-bezier(0.4, 0, 1, 1)";
+
+export declare const easingDecelerate = "cubic-bezier(0.0, 0, 0.2, 1)";
+
+export declare const easingStandard = "cubic-bezier(0.4, 0, 0.2, 1)";
+
 declare type EdgeAlignment = "start" | "end" | "center";
 
 declare interface EvanceUiOptions {
@@ -4750,9 +5023,15 @@ declare class EvDrawerServiceOpener {
 declare interface EvDrawerServiceOptions extends EvDialogServiceOptions {
 }
 
-declare type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
+/**
+ * # Event Name
+ * @param propName
+ */
+export declare function eventName(propName: string): string;
+
+export declare type EventProp<T extends any[] = any[], F = (...args: T) => any> = F | F[];
 
-declare const EventProp: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;
+export declare const EventProp: <T extends any[] = any[]>() => PropType<EventProp<T, (...args: T) => any>>;
 
 export declare const EvErrors: DefineComponent<    {
 class: PropType<any>;
@@ -4796,7 +5075,7 @@ type: PropType<string>;
 default: string;
 };
 appearance: {
-type: PropType<TextAppearanceProp_2>;
+type: PropType<TextAppearanceProp>;
 default: "default";
 };
 text: StringConstructor;
@@ -4814,12 +5093,12 @@ type: PropType<string>;
 default: string;
 };
 appearance: {
-type: PropType<TextAppearanceProp_2>;
+type: PropType<TextAppearanceProp>;
 default: "default";
 };
 text: StringConstructor;
 }>>, {
-appearance: TextAppearanceProp_2;
+appearance: TextAppearanceProp;
 style: StyleValue;
 tag: string;
 }, {}>, Readonly<{
@@ -9569,6 +9848,27 @@ export declare type EvWindowSlots = {
 
 export declare const EvWindowSymbol: InjectionKey<WindowProvide>;
 
+/**
+ * # extractWebUnit
+ * @param value
+ */
+export declare function extractWebUnit(value: string): {
+    value: number;
+    unit: string;
+};
+
+/**
+ * # Filter Component Props
+ *
+ * Extracts the component's props from a props record.
+ *
+ * Excludes `class` and `style`.
+ *
+ * @param component
+ * @param props
+ */
+export declare function filterComponentProps(component: ComponentOptions<any>, props: Record<string, any>): Partial<Record<string, any>>;
+
 declare type FilterFunction = (value: string, query: string, item?: InternalItem) => FilterMatch;
 
 declare type FilterKeyFunctions = Record<string, FilterFunction>;
@@ -9585,16 +9885,54 @@ declare type FilterMatch = boolean | number | [number, number] | [number, number
 
 declare type FilterMode = "some" | "every" | "union" | "intersection";
 
+/**
+ * # findChildren
+ *
+ * @param vnode
+ */
+export declare function findChildren(vnode?: VNodeChild): ComponentInternalInstance[];
+
+/**
+ * # findChildrenWithProvide
+ *
+ * @param key
+ * @param vnode
+ */
+export declare function findChildrenWithProvide(key: InjectionKey<any> | symbol, vnode?: VNodeChild): ComponentInternalInstance[];
+
 /**
  * # Set Focus
  * @param position
  */
 declare function focus_2(position?: FocusPosition): void;
 
+/**
+ * # focusableChildren
+ *
+ * Find children within the supplied `el` we focus to.
+ *
+ * @param el
+ * @param filterByTabIndex
+ */
+export declare function focusableChildren(el: Element, filterByTabIndex?: boolean): HTMLElement[];
+
+/**
+ * # Focusable Elements
+ * A list of elements we can focus on dynamically.
+ */
+export declare const focusableElements: string[];
+
+/**
+ * # Focus Child
+ * @param el
+ * @param position
+ */
+export declare function focusChild(el?: Element, position?: FocusPosition): HTMLElement | undefined;
+
 /**
  * # Focus Position
  */
-declare type FocusPosition = "next" | "previous" | "first" | "last";
+export declare type FocusPosition = "next" | "previous" | "first" | "last";
 
 export declare type FontWeight = "regular" | "medium" | "semibold" | "bold";
 
@@ -9781,6 +10119,103 @@ declare interface FormProps {
     validateOn?: FormFieldProps["validateOn"];
 }
 
+/**
+ * # Get Current Component
+ *
+ * Gets the current instance of component from vue.
+ *
+ * @param callee
+ */
+export declare function getCurrentComponent(callee: string): ComponentInternalInstance;
+
+/**
+ * # Get Focusable Children
+ *
+ * Find and return any focusable elements within the supplied element,
+ * unless they're disabled or have a negative `tabindex` of -1.
+ *
+ * @param el
+ * @param filterByTabIndex
+ */
+export declare function getFocusableChildren(el: Element, filterByTabIndex?: boolean): HTMLElement[];
+
+/**
+ * # Get Nested Property Value
+ *
+ * @param subject
+ * @param propertyKeys
+ * @param fallback
+ */
+export declare function getNestedPropertyValue(subject: any, propertyKeys: PropertyKey[], fallback?: any): any;
+
+export declare function getNextId(): number;
+
+export declare namespace getNextId {
+    var reset: () => void;
+}
+
+/**
+ * # Get Descriptor
+ *
+ * Returns the closest property descriptor for an object.
+ *
+ * @param obj
+ * @param key
+ */
+export declare function getPropertyDescriptor(obj: any, key: PropertyKey): TypedPropertyDescriptor<any>;
+
+/**
+ * # Get Property
+ *
+ * A getter function, which gets a property from the `subject`, which may be
+ * any kind of object.
+ *
+ */
+export declare function getPropertyValue(subject: any, property: GetterPropertyKey, fallback?: any): any;
+
+/**
+ * # Get Property from Path
+ *
+ * This is a rough copy of Evance's `EvObjectPathGetter` functionality.
+ *
+ * @param subject
+ * @param objectPath
+ * @param fallback
+ */
+export declare function getPropertyValueByPath(subject: any, objectPath: string, fallback?: any): any;
+
+/**
+ * # Get Scroll Parent
+ *
+ * Get the closest parent element which is scrollable.
+ *
+ * @param el
+ * @param isIncludeHidden
+ * @param axis
+ */
+export declare function getScrollParent(el?: Element, isIncludeHidden?: boolean, axis?: Axis | null): HTMLElement;
+
+/**
+ * # Get Scroll Parents
+ *
+ * Get all parent elements with a scrollbar in either the x-axis, y-axis,
+ * or either if `axis` is supplied as `null`.
+ *
+ * Defaults to y-axis, since that's the most common use-case.
+ *
+ * @param el
+ * @param stopAt
+ * @param axis
+ */
+export declare function getScrollParents(el: Element | undefined, stopAt?: Element | null, axis?: Axis | null): HTMLElement[];
+
+/**
+ * # getTargetRect
+ *
+ * @param target
+ */
+export declare function getTargetRect(target: HTMLElement | [x: number, y: number]): Rect | DOMRect;
+
 /**
  * # Getter Property Key
  *
@@ -9794,7 +10229,7 @@ declare interface FormProps {
  * - `array` of strings or numbers represent nested lookup - each array element represents a key in the hierarchy
  * - A callback function accepting `item` and `fallback` arguments.
  */
-declare type GetterPropertyKey<T = Record<string, any>> = boolean | null | undefined | string | (string | number)[] | ((item: T, fallback?: any) => any);
+export declare type GetterPropertyKey<T = Record<string, any>> = boolean | null | undefined | string | (string | number)[] | ((item: T, fallback?: any) => any);
 
 /**
  * # GroupItem
@@ -9844,6 +10279,36 @@ declare interface GroupProvide {
     getItemIndex: (value: unknown) => number;
 }
 
+/**
+ * # Has Event Listener
+ *
+ * Determines whether the `props` supplied includes an event listener, or
+ * any variations of the event listener. For example, 'click' events may have:
+ * - 'onClick'
+ * - 'onClickOnce'
+ * - 'onClickOnceCapture'
+ * - 'onClickCaptureOnce'
+ *
+ * @param props
+ * @param name
+ */
+export declare function hasEventListener(props: Record<string, any>, name: string): boolean;
+
+/**
+ * # Has Scrollbar?
+ *
+ * Determine whether an Element has a Scrollbar in either the x-axis, y-axis,
+ * or either if `axis` is supplied as `null`.
+ *
+ * This does not necessarily mean it has a scroll amount.
+ *
+ * Defaults to y-axis, since that's the most common use-case.
+ *
+ * @param el
+ * @param axis
+ */
+export declare function hasScrollbar(el?: Element | null, axis?: Axis | null): boolean;
+
 declare type HeaderCellProps = Record<string, any> | ((data: Pick<ItemKeySlot<any>, "index" | "item" | "internalItem" | "value">) => Record<string, any>);
 
 declare type HorizontalSide = "left" | "right";
@@ -9871,6 +10336,23 @@ export declare type IconSize = "small" | "medium" | "large";
 
 declare type IconValue = string | (string | [path: string, opacity: number])[];
 
+/**
+ * # If Any
+ */
+declare type IfAny<T, Y, N> = 0 extends 1 & T ? Y : N;
+
+declare type InferPropType<T> = [T] extends [null] ? any : [T] extends [{
+    type: null | true;
+}] ? any : [T] extends [ObjectConstructor | {
+    type: ObjectConstructor;
+}] ? Record<string, any> : [T] extends [BooleanConstructor | {
+    type: BooleanConstructor;
+}] ? boolean : [T] extends [DateConstructor | {
+    type: DateConstructor;
+}] ? Date : [T] extends [(infer U)[] | {
+    type: (infer U)[];
+}] ? U extends DateConstructor ? Date | InferPropType<U> : InferPropType<U> : [T] extends [Prop<infer V, infer D>] ? unknown extends V ? IfAny_2<V, V, D> : V : T;
+
 export declare type InfiniteScrollDirection = "vertical" | "horizontal";
 
 export declare type InfiniteScrollMode = "intersect" | "manual";
@@ -9889,22 +10371,24 @@ export declare function injectDialog(): EvDialogInstance | undefined;
  */
 export declare function injectDrawer(): EvDrawerInstance | undefined;
 
+export declare function injectSelf<T>(key: InjectionKey<T> | string, vm?: ComponentInternalInstance): T | undefined;
+
 /**
  * # Input Appearance
  */
-declare const InputAppearance: {
+export declare const InputAppearance: {
     readonly default: "default";
     readonly button: "button";
     readonly none: "none";
     readonly subtle: "subtle";
 };
 
-declare type InputAppearanceProp = (typeof InputAppearance)[keyof typeof InputAppearance];
+export declare type InputAppearanceProp = (typeof InputAppearance)[keyof typeof InputAppearance];
 
 /**
  * # Input Sizes
  */
-declare const InputSize: {
+export declare const InputSize: {
     readonly default: "medium";
     readonly xSmall: "x-small";
     readonly small: "small";
@@ -9913,7 +10397,12 @@ declare const InputSize: {
     readonly xLarge: "x-large";
 };
 
-declare type InputSizeProp = (typeof InputSize)[keyof typeof InputSize];
+export declare type InputSizeProp = (typeof InputSize)[keyof typeof InputSize];
+
+/**
+ * # Integerish Pattern
+ */
+export declare const IntegerishPattern: RegExp;
 
 declare type InternalDataTableHeader = Omit<DataTableHeader, "key" | "value" | "children" | "hidden"> & {
     key: string | null;
@@ -9948,6 +10437,56 @@ export declare const Intersect: {
     unmounted: typeof unmounted;
 };
 
+/**
+ * # Is (equal)
+ * I had written a polyfill for this, but since we're only interested in modern browsers
+ * let's reduce code and simply return the result from Object.is();
+ * @param a
+ * @param b
+ */
+export declare function is(a?: any, b?: any): boolean;
+
+/**
+ * # Is Array?
+ * @param value
+ */
+export declare function isArray(value: unknown): boolean;
+
+/**
+ * # Is Boolean?
+ * @param value
+ */
+export declare function isBoolean(value: unknown): value is boolean;
+
+/**
+ * # isComposingIgnoreKey
+ * Returns `true` if the keyboard event is within a composing sequence,
+ * and the key pressed is included within `compositionIgnoreKeys`.
+ */
+export declare function isComposingIgnoreKey(e: KeyboardEvent): boolean;
+
+/**
+ * # Is CSS Variable
+ * @param value
+ */
+export declare function isCssVariable(value: unknown): boolean;
+
+/**
+ * # Is Date?
+ * @param value
+ */
+export declare function isDate(value: unknown): value is Date;
+
+/**
+ * # Is Date Equal
+ *
+ * Evaluates whether one date equals another date.
+ *
+ * @param a
+ * @param b
+ */
+export declare function isDateEqual(a: Date, b: Date): boolean;
+
 /**
  * # Is Deep Equal?
  *
@@ -9959,7 +10498,97 @@ export declare const Intersect: {
  * @param a
  * @param b
  */
-declare function isDeepEqual(a: any, b: any): boolean;
+export declare function isDeepEqual(a: any, b: any): boolean;
+
+export declare function isElement(el: unknown): el is Element;
+
+/**
+ * # Is Empty
+ * @param value
+ */
+export declare function isEmpty(value: any): boolean;
+
+/**
+ * # Is Equal NaN
+ *
+ * Check if a value is NaN - the only value in JavaScript that is not equal to itself.
+ *
+ * @param value
+ */
+export declare function isEqualNaN(value: unknown): boolean;
+
+export declare function isFixedPosition(el?: HTMLElement): boolean;
+
+/**
+ * # Is Function?
+ * @param value
+ */
+export declare function isFunction(value: unknown): value is Function;
+
+/**
+ * # Is Integerish
+ * @param value
+ */
+export declare function isIntegerish(value: string | number): boolean;
+
+/**
+ * # Is Key Event Loggable?
+ * @param e
+ */
+export declare function isKeyEventLoggable(e: KeyboardEvent): boolean;
+
+/**
+ * # Is Number
+ * @param value
+ */
+export declare function isNumber(value: unknown): value is number;
+
+/**
+ * # Is Object?
+ * @param value
+ */
+export declare function isObject(value: unknown): value is object;
+
+/**
+ * # Is Object Not Array
+ * @param value
+ */
+export declare function isObjectNotArray(value: any): boolean;
+
+export declare const isOn: (key: string) => boolean;
+
+/**
+ *
+ * @param value
+ */
+export declare function isPrimitive(value: unknown): value is string | number | boolean;
+
+/**
+ * # Is Scrollable?
+ *
+ * Determines whether an Element is scrollable in either the x-axis, y-axis,
+ * or either if `axis` is supplied as `null`.
+ *
+ * Defaults to y-axis, since that's the most common use-case.
+ *
+ * @param el
+ * @param axis
+ */
+export declare function isScrollable(el: Element | null, axis?: Axis | null): boolean;
+
+/**
+ * # Is ShadowRoot
+ * @param value
+ */
+export declare function isShadowRoot(value: unknown): value is ShadowRoot;
+
+/**
+ * # Is String?
+ * @param value
+ */
+export declare function isString(value: unknown): value is string;
+
+export declare function isTypeOf(value: unknown, accept: string[]): boolean;
 
 declare type ItemKeySlot<T> = ItemSlotBase<T> & {
     value: any;
@@ -9984,8 +10613,24 @@ export declare type JustifyContentObject = {
 
 export declare type JustifyContentProp = JustifyContentValue | JustifyContentObject | undefined;
 
-/** Justify Content **/
-export declare type JustifyContentValue = "start" | "end" | "center" | "space-between" | "space-around" | "space-evenly";
+/** Justify Content **/
+export declare type JustifyContentValue = "start" | "end" | "center" | "space-between" | "space-around" | "space-evenly";
+
+/**
+ * # Key Logger
+ */
+export declare class KeyLogger {
+    lastTime: number;
+    timeToKeep: number;
+    value: string;
+    /**
+     * ## Log
+     * @param e
+     */
+    log(e: KeyboardEvent): boolean;
+}
+
+export declare function keys<O extends {}>(o: O): (keyof O)[];
 
 /**
  * # Language Pack
@@ -10208,6 +10853,42 @@ export declare const makeActivatorProps: <Defaults extends {
     };
 };
 
+export declare const makeAppearanceProps: <Defaults extends {
+    appearance?: unknown;
+    variant?: unknown;
+} = {}>(defaults?: Defaults) => {
+    appearance: unknown extends Defaults["appearance"] ? {
+        type: PropType<AppearanceProp>;
+        default: "default";
+    } : Omit<{
+        type: PropType<AppearanceProp>;
+        default: "default";
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["appearance"] ? AppearanceProp : Defaults["appearance"] | NonNullable<AppearanceProp>>;
+        default: unknown extends Defaults["appearance"] ? AppearanceProp : Defaults["appearance"] | NonNullable<AppearanceProp>;
+    };
+    variant: unknown extends Defaults["variant"] ? {
+        type: PropType<VariantProp>;
+        default: "default";
+    } : Omit<{
+        type: PropType<VariantProp>;
+        default: "default";
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["variant"] ? VariantProp : NonNullable<VariantProp> | Defaults["variant"]>;
+        default: unknown extends Defaults["variant"] ? VariantProp : NonNullable<VariantProp> | Defaults["variant"];
+    };
+};
+
+/**
+ * ## Make Class Name
+ * Accepts a string `value` and a `prefix` to be combined and separated by a dash ("-").
+ * The value will be converted into "kebab-case".
+ * @param value
+ * @param prefix
+ * @param exclude
+ */
+export declare function makeClassName(value?: string, prefix?: string, exclude?: (string | RegExp)[]): string | undefined;
+
 /**
  * # Make Elevation Class
  */
@@ -15102,14 +15783,14 @@ export declare const makeEvEyebrowProps: <Defaults extends {
         default: unknown extends Defaults["tag"] ? string : string | Defaults["tag"];
     };
     appearance: unknown extends Defaults["appearance"] ? {
-        type: PropType<TextAppearanceProp_2>;
+        type: PropType<TextAppearanceProp>;
         default: "default";
     } : Omit<{
-        type: PropType<TextAppearanceProp_2>;
+        type: PropType<TextAppearanceProp>;
         default: "default";
     }, "type" | "default"> & {
-        type: PropType<unknown extends Defaults["appearance"] ? TextAppearanceProp_2 : NonNullable<TextAppearanceProp_2> | Defaults["appearance"]>;
-        default: unknown extends Defaults["appearance"] ? TextAppearanceProp_2 : NonNullable<TextAppearanceProp_2> | Defaults["appearance"];
+        type: PropType<unknown extends Defaults["appearance"] ? TextAppearanceProp : NonNullable<TextAppearanceProp> | Defaults["appearance"]>;
+        default: unknown extends Defaults["appearance"] ? TextAppearanceProp : NonNullable<TextAppearanceProp> | Defaults["appearance"];
     };
     text: unknown extends Defaults["text"] ? StringConstructor : {
         type: PropType<unknown extends Defaults["text"] ? string : string | Defaults["text"]>;
@@ -20505,8 +21186,8 @@ export declare const makeEvTextProps: <Defaults extends {
         default: unknown extends Defaults["style"] ? StyleValue : NonNullable<StyleValue> | Defaults["style"];
     };
     appearance: unknown extends Defaults["appearance"] ? PropType<TextAppearanceProp> : {
-        type: PropType<unknown extends Defaults["appearance"] ? TextAppearanceProp : Defaults["appearance"] | NonNullable<TextAppearanceProp>>;
-        default: unknown extends Defaults["appearance"] ? TextAppearanceProp : Defaults["appearance"] | NonNullable<TextAppearanceProp>;
+        type: PropType<unknown extends Defaults["appearance"] ? TextAppearanceProp : NonNullable<TextAppearanceProp> | Defaults["appearance"]>;
+        default: unknown extends Defaults["appearance"] ? TextAppearanceProp : NonNullable<TextAppearanceProp> | Defaults["appearance"];
     };
     monospace: unknown extends Defaults["monospace"] ? BooleanConstructor : {
         type: PropType<unknown extends Defaults["monospace"] ? boolean : boolean | Defaults["monospace"]>;
@@ -21267,6 +21948,36 @@ export declare const makeEvWindowProps: <Defaults extends {
     };
 };
 
+export declare const makeInputAppearanceProps: <Defaults extends {
+    appearance?: unknown;
+} = {}>(defaults?: Defaults) => {
+    appearance: unknown extends Defaults["appearance"] ? {
+        type: PropType<InputAppearanceProp>;
+        default: "default";
+    } : Omit<{
+        type: PropType<InputAppearanceProp>;
+        default: "default";
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["appearance"] ? InputAppearanceProp : Defaults["appearance"] | NonNullable<InputAppearanceProp>>;
+        default: unknown extends Defaults["appearance"] ? InputAppearanceProp : Defaults["appearance"] | NonNullable<InputAppearanceProp>;
+    };
+};
+
+export declare const makeInputSizeProps: <Defaults extends {
+    size?: unknown;
+} = {}>(defaults?: Defaults) => {
+    size: unknown extends Defaults["size"] ? {
+        type: PropType<InputSizeProp>;
+        default: "medium";
+    } : Omit<{
+        type: PropType<InputSizeProp>;
+        default: "medium";
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["size"] ? InputSizeProp : Defaults["size"] | NonNullable<InputSizeProp>>;
+        default: unknown extends Defaults["size"] ? InputSizeProp : Defaults["size"] | NonNullable<InputSizeProp>;
+    };
+};
+
 export declare const makeLabelProps: <Defaults extends {
     label?: unknown;
     hint?: unknown;
@@ -21348,12 +22059,54 @@ export declare const makeScrollStrategyProps: <Defaults extends {
     };
 };
 
+export declare const makeTextAlignProps: <Defaults extends {
+    align?: unknown;
+} = {}>(defaults?: Defaults) => {
+    align: unknown extends Defaults["align"] ? {
+        type: PropType<TextAlignProp>;
+        default: "left";
+    } : Omit<{
+        type: PropType<TextAlignProp>;
+        default: "left";
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["align"] ? TextAlignProp : Defaults["align"] | NonNullable<TextAlignProp>>;
+        default: unknown extends Defaults["align"] ? TextAlignProp : Defaults["align"] | NonNullable<TextAlignProp>;
+    };
+};
+
+export declare const makeTextAppearanceProps: <Defaults extends {
+    appearance?: unknown;
+} = {}>(defaults?: Defaults) => {
+    appearance: unknown extends Defaults["appearance"] ? {
+        type: PropType<TextAppearanceProp>;
+        default: "default";
+    } : Omit<{
+        type: PropType<TextAppearanceProp>;
+        default: "default";
+    }, "type" | "default"> & {
+        type: PropType<unknown extends Defaults["appearance"] ? TextAppearanceProp : Defaults["appearance"] | NonNullable<TextAppearanceProp>>;
+        default: unknown extends Defaults["appearance"] ? TextAppearanceProp : Defaults["appearance"] | NonNullable<TextAppearanceProp>;
+    };
+};
+
 /**
  * # Margins
  * Essentially the same as Position, but is intended to describe areas outside the box
  * (same as CSS `margin`).
  */
-declare type Margins = Position;
+export declare type Margins = Position;
+
+/**
+ * # matchesSelector
+ * Returns `null` if the CSS selector is not supported, or can't be checked.
+ * @param el
+ * @param selector
+ */
+export declare function matchesSelector(el: Element | undefined, selector: string): boolean | null;
+
+export declare function mergeDeep(source?: Record<string, any>, target?: Record<string, any>, arrayFn?: (a: unknown[], b: unknown[]) => unknown[]): Record<string, any>;
+
+declare type MergeDefault<T, D> = unknown extends D ? InferPropType<T> : NonNullable<InferPropType<T>> | D;
 
 declare type ModelValueProp = boolean | Ref<boolean>;
 
@@ -21366,6 +22119,10 @@ declare function mounted(el: ObserveHTMLElement, binding: ObserverDirectiveBindi
 
 declare function mounted_2(el: TouchableElement, binding: TouchDirectiveBinding): void;
 
+declare type NotAUnion<T> = [T] extends [infer U] ? _NotAUnion<U, U> : never;
+
+declare type _NotAUnion<T, U> = U extends any ? [T] extends [U] ? unknown : never : never;
+
 declare interface Notification_2 {
     id: number;
     props: EvNotificationProps;
@@ -21507,6 +22264,15 @@ export declare interface NumberParserProps {
     useGrouping?: boolean;
 }
 
+/**
+ * # Object Path To Array
+ *
+ * This is a rough copy of Evance's `EvObjectPath` functionality.
+ *
+ * @param path
+ */
+export declare function objectPathToPropertyKeys(path: string): PropertyKey[];
+
 declare interface ObserveHTMLElement extends HTMLElement {
     _observe?: {
         init: boolean;
@@ -21527,6 +22293,16 @@ export declare interface ObserverDirectiveBinding extends Omit<DirectiveBinding,
 
 declare type ObserverHandler = (isIntersecting: boolean, entries: IntersectionObserverEntry[], observer: IntersectionObserver) => void;
 
+/**
+ * # Omit
+ *
+ * Clones an object, whilst omitting excluded properties.
+ *
+ * @param obj
+ * @param exclude
+ */
+export declare function omit<T extends object, U extends Extract<keyof T, string>>(obj: T, exclude: U[]): Omit<T, U>;
+
 declare function onChange(): void;
 
 /**
@@ -21572,7 +22348,46 @@ declare type OpenStrategyFn = (data: OpenStrategyData) => Set<unknown>;
  */
 declare type OpenStrategyRef = "single" | "multiple" | "list";
 
-declare type PhysicalSide = HorizontalSide | VerticalSide;
+/**
+ * # Pad End
+ *
+ * @param str
+ * @param length
+ * @param char
+ */
+export declare function padEnd(str: string, length: number, char?: string): string;
+
+/**
+ * # Pad Start
+ *
+ * @param str
+ * @param length
+ * @param char
+ */
+export declare function padStart(str: string, length: number, char?: string): string;
+
+/**
+ * Like `Partial<T>` but doesn't care what the value is
+ */
+declare type PartialKeys<T> = {
+    [P in keyof T]?: unknown;
+};
+
+export declare type PhysicalAlignment = "left" | "right" | "center";
+
+export declare type PhysicalSide = HorizontalSide | VerticalSide;
+
+/**
+ * # Pixel Ceil
+ * @param value
+ */
+export declare function pixelCeil(value: number): number;
+
+/**
+ * # Pixel Round
+ * @param value
+ */
+export declare function pixelRound(value: number): number;
 
 declare type PluralizationRuleKey = (typeof pluralizationRuleKeys)[number];
 
@@ -21595,7 +22410,7 @@ declare type PluralizationRules = {
  * # Position
  * Representative of an element's position attributes describing the bounding area of a box.
  */
-declare interface Position {
+export declare interface Position {
     top: number;
     right: number;
     bottom: number;
@@ -21645,6 +22460,38 @@ declare interface ProgressProps_2 {
     thickness?: number;
 }
 
+/**
+ * # Props Factory
+ *
+ * Creates a factory function for props definitions.
+ * This is used to define props in a composable then override
+ * default values in an implementing component.
+ *
+ * @example Simplified signature
+ * (props: Props) => (defaults?: Record<keyof props, any>) => Props
+ *
+ * @example Usage
+ * const makeProps = propsFactory({
+ *   foo: String,
+ * })
+ *
+ * defineComponent({
+ *   props: {
+ *     ...makeProps({
+ *       foo: 'a',
+ *     }),
+ *   },
+ *   setup (props) {
+ *     // would be "string | undefined", now "string" because a default has been provided
+ *     props.foo
+ *   },
+ * }
+ *
+ * Copied from Vuetify
+ * @see https://github.com/vuetifyjs/vuetify/blob/master/packages/vuetify/src/util/propsFactory.ts
+ */
+export declare function propsFactory<PropsOptions extends ComponentObjectPropsOptions>(props: PropsOptions, source: string): <Defaults extends PartialKeys<PropsOptions> = {}>(defaults?: Defaults) => AppendDefault<PropsOptions, Defaults>;
+
 declare function provideSelection(props: SelectionProps, { allItems, currentPage, }: {
     allItems: Ref<SelectableItem[]>;
     currentPage: Ref<SelectableItem[]>;
@@ -21671,12 +22518,24 @@ declare interface QuickfindProps {
 
 declare type QuickfindSize = "small" | "medium" | "large";
 
+/**
+ * # randomArrayItem
+ *
+ * Returns a random element from any array, or `undefined` if the array is empty.
+ *
+ * You can change the value returned if the array is empty by supplying the `emptyValue`.
+ *
+ * @param array
+ * @param emptyValue
+ */
+export declare function randomArrayItem(array: any[], emptyValue?: any): any;
+
 /**
  * # Rect
  *
  * Describes a bounding rectangle a bit like DOMRect, but not readonly.
  */
-declare class Rect implements Coordinates, Dimensions, Position {
+export declare class Rect implements Coordinates, Dimensions, Position {
     x: number;
     y: number;
     width: number;
@@ -21712,9 +22571,35 @@ declare class Rect implements Coordinates, Dimensions, Position {
     getOverflow(b: Rect): Margins;
 }
 
-declare interface RectProps extends Coordinates, Dimensions {
+export declare interface RectProps extends Coordinates, Dimensions {
 }
 
+/**
+ * # Ref Element
+ * @param obj
+ */
+export declare function refElement<T extends object | undefined>(obj: T): Exclude<T, ComponentPublicInstance> | HTMLElement;
+
+/**
+ * # registerComponent
+ *
+ * Register a component to the vue app instance.
+ *
+ * @param app
+ * @param component
+ */
+export declare const registerComponent: (app: App, component: Component) => void;
+
+/**
+ * # registerPlugin
+ *
+ * Register a plugin to the vue app instance.
+ *
+ * @param app
+ * @param plugin
+ */
+export declare const registerPlugin: (app: App, plugin: Plugin_2) => void;
+
 /**
  * # Reposition Scroll Strategy
  * @param data
@@ -21723,6 +22608,12 @@ declare interface RectProps extends Coordinates, Dimensions {
  */
 declare function repositionScrollStrategy(data: ScrollStrategyData, props: ScrollStrategyProps, scope: EffectScope): void;
 
+/**
+ * Schedule a task to run in an animation frame on its own
+ * This is useful for heavy tasks that may cause jank if all ran together
+ */
+export declare function requestNewFrame(callback: () => void): void;
+
 declare function reset(status?: InfiniteScrollStatus): void;
 
 declare function resetScroll(status?: InfiniteScrollStatus): void;
@@ -21830,6 +22721,15 @@ declare namespace services {
 }
 export { services }
 
+/**
+ * # setVueInstance
+ *
+ * Set the global vue instance
+ *
+ * @param Vue
+ */
+export declare const setVueInstance: (Vue: App) => void;
+
 declare const Size: {
     readonly default: "medium";
     readonly xSmall: "x-small";
@@ -21841,6 +22741,13 @@ declare const Size: {
 
 declare type Size_2 = "default";
 
+/**
+ * ## Make a Size Modifier Class Name
+ * @param value
+ * @param exclude
+ */
+export declare function sizeModifier(value?: string | number, exclude?: (string | RegExp)[]): string | undefined;
+
 declare type SizeProp = SizeValue | number;
 
 declare type SizeValue = (typeof Size)[keyof typeof Size];
@@ -21872,6 +22779,44 @@ export declare type SpacerProp = SpacerValue | SpacerObject | undefined;
 /** Spacers **/
 export declare type SpacerValue = number | string | undefined;
 
+/**
+ * # spaceSeparatedValues
+ *
+ * Accepts a string and converts it into an array of values.
+ *
+ * @param values
+ */
+export declare function spaceSeparatedValues(values?: string): string[];
+
+export declare namespace spaceSeparatedValues {
+    var cache: Map<string, string[]>;
+}
+
+/**
+ * ## Split Input Attrs
+ *
+ * Filter/split an attributes objects into two objects:
+ * 1. Attributes not intended for an input field.
+ * 2. Attributes for an input field.
+ *
+ * @param attrs
+ */
+export declare function splitInputAttrs(attrs: Record<string, unknown>): [matched: Partial<Record<string, unknown>>, unmatched: Partial<Record<string, unknown>>];
+
+/**
+ * # Split Object
+ *
+ * Split an object into two using an Array of keys or RegExp to test keys against.
+ *
+ * This results an array containing an object containing only matching keys,
+ * and an object containing the remaining keys.
+ *
+ * @param subject
+ * @param paths
+ * @param exclude
+ */
+export declare function splitObject<Subject extends object, SubjectKey extends Extract<keyof Subject, string>, Exclusions extends Extract<keyof Subject, string>>(subject: Subject, paths: (SubjectKey | RegExp)[], exclude?: Exclusions[]): [matched: Partial<Subject>, unmatched: Partial<Subject>];
+
 declare type SSROptions = boolean | {
     clientWidth: number;
     clientHeight?: number;
@@ -21884,7 +22829,7 @@ declare type SSROptions = boolean | {
  */
 declare function staticPositionStrategy(data: PositionStrategyData, props: PositionStrategyProps, contentStyles: Ref<StyleProp>): void;
 
-declare type StyleProp = Record<string, string>;
+export declare type StyleProp = Record<string, string>;
 
 /**
  * # Surface Elevation
@@ -21906,22 +22851,45 @@ declare interface TagProps {
 
 declare type TeleportTarget = boolean | string | Element;
 
+/**
+ * # Template Function
+ *
+ * A template function is returned from `createStringTemplate`, which converts the template
+ * into a string, replacing any variables with those contained within the variables supplied.
+ *
+ * @see createStringTemplate
+ */
+export declare type TemplateFunction = (variables?: TemplateVariables) => string;
+
+/**
+ * ## Template Variables
+ *
+ * May be supplied to `createStringTemplate()` either as default variable replacements
+ * or during template execution for variable replacement.
+ *
+ * @see createStringTemplate
+ */
+export declare type TemplateVariables = {
+    [variable: string]: number | string;
+};
+
 /**
  * # Text Align
  */
-declare const TextAlign: {
+export declare const TextAlign: {
     readonly default: "left";
     readonly left: "left";
     readonly center: "center";
     readonly right: "right";
 };
 
-declare type TextAlignProp = (typeof TextAlign)[keyof typeof TextAlign];
+export declare type TextAlignProp = (typeof TextAlign)[keyof typeof TextAlign];
 
 /**
  * Text Appearance
  */
-declare const TextAppearance: {
+export declare const TextAppearance: {
+    readonly inverse: "inverse";
     readonly subtle: "subtle";
     readonly default: "default";
     readonly danger: "danger";
@@ -21932,9 +22900,44 @@ declare const TextAppearance: {
     readonly warning: "warning";
 };
 
-export declare type TextAppearanceProp = AppearanceProp | "inverse" | "subtle";
+export declare type TextAppearanceProp = (typeof TextAppearance)[keyof typeof TextAppearance];
+
+export declare interface TextAppearanceProps {
+    appearance: TextAppearanceProp;
+}
+
+/**
+ * # To Camel Case
+ *
+ * Converts a string from `kebab-case` to `camelCase`.
+ *
+ * @param value
+ */
+export declare function toCamelCase(value?: string): string;
+
+export declare namespace toCamelCase {
+    var cache: Map<string, string>;
+}
+
+/**
+ * # Set Fixed Position
+ * @param style
+ * @param isRtl
+ */
+export declare function toFixedPosition(style: StyleProp, isRtl?: boolean): void;
+
+/**
+ * # To Kebab Case
+ *
+ * Converts a string to `kebab-case` by replacing each space or letter capitalization with a dash (-).
+ *
+ * @param value
+ */
+export declare function toKebabCase(value?: string): string;
 
-declare type TextAppearanceProp_2 = (typeof TextAppearance)[keyof typeof TextAppearance];
+export declare namespace toKebabCase {
+    var cache: Map<string, string>;
+}
 
 declare const Touch_2: {
     mounted: typeof mounted_2;
@@ -21992,6 +22995,13 @@ export declare interface TouchValue extends TouchHandlers {
 
 export declare type TouchWrapper = TouchHandlers & TouchData;
 
+/**
+ * # To Web Unit
+ * @param value
+ * @param unit
+ */
+export declare function toWebUnit(value?: string | number, unit?: string): string | undefined;
+
 /**
  * # Translatable
  */
@@ -22087,6 +23097,14 @@ declare class Translator extends Localized {
     translate(reference: string, variables?: TranslationVariables, locale?: string | undefined): string | undefined;
 }
 
+/**
+ * # Trim End
+ *
+ * @param targetString
+ * @param trimChars
+ */
+export declare function trimEnd(targetString: string, trimChars: string): string;
+
 /**
  * # UI Mouse Event
  * `sourceCapabilities` is in labs according to MDN. So it is subject to change.
@@ -22099,6 +23117,22 @@ declare interface UIMouseEvent extends MouseEvent {
     };
 }
 
+/**
+ * # Unbind Props
+ * @param el
+ * @param props
+ */
+export declare function unbindProps(el: HTMLElement, props: Record<string, any>): void;
+
+/**
+ * # Union To Intersection
+ *
+ * Intersection `I` of all types in the union `U` - transform a union of object types into an intersection of those types.
+ * This can be helpful when you want to combine multiple types into a single type, where all properties from each type
+ * become part of the resulting type.
+ */
+export declare type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
 /**
  * # Unmounted
  */
@@ -22115,6 +23149,21 @@ declare function unmounted_2(el: HTMLElement, binding: TouchDirectiveBinding): v
  */
 export declare function useActivator(props: ActivatorProps, isActive: Ref<boolean>, isTopOfStack: Ref<boolean>): Activator;
 
+/**
+ * # useAppearance
+ *
+ * @param props
+ * @param group
+ * @param isActive
+ * @param defaultVariant
+ */
+export declare function useAppearance(props: MaybeRef<Partial<AppearanceProps>>, group?: GroupItemProvide | null, isActive?: Ref<boolean | undefined> | null, defaultVariant?: string): {
+    appearance: ComputedRef<string>;
+    appearanceClass: ComputedRef<string>;
+    variant: ComputedRef<string>;
+    variantClass: ComputedRef<string>;
+};
+
 /**
  * # useAspectStyles
  *
@@ -22222,6 +23271,10 @@ export declare function usePositionStrategies(props: PositionStrategyProps, data
  */
 export declare function useScrollStrategies(props: ScrollStrategyProps, data: ScrollStrategyData): void;
 
+export declare function useTextAppearance(props: TextAppearanceProps): {
+    appearanceClass: ComputedRef<string>;
+};
+
 /**
  * # Use Toggle Control
  *
@@ -22259,7 +23312,7 @@ declare type ValidationResult = string | boolean;
  */
 declare type Validator = ValidationResult | PromiseLike<ValidationResult> | ((value: any) => ValidationResult) | ((value: any) => PromiseLike<ValidationResult>);
 
-declare const Variant: {
+export declare const Variant: {
     readonly default: "default";
     readonly bold: "bold";
     readonly outlined: "outlined";
@@ -22267,32 +23320,14 @@ declare const Variant: {
     readonly tonal: "tonal";
 };
 
-declare type VariantProp = (typeof Variant)[keyof typeof Variant];
-
 /**
- * # Click Outside Directive
- *
- * There are two handlers:
- * 1. onClick - handles click events, which are triggered after...
- * 2. onMouseDown - determines if the mouse was outside before the click event finished.
- *
- * This helps us get over an issue we had previously, where mouse dragging during a click
- * caused dialogs to close unwantedly.
+ * ## Make a Variant Modifier Class Name
+ * @param value
+ * @param exclude
  */
-export declare const vClickOutside: {
-    /**
-     * Add event listeners when the component is mounted.
-     * @param el
-     * @param binding
-     */
-    mounted(el: ClickOutsideHTMLElement, binding: ClickOutsideBinding): void;
-    /**
-     * Remove event listeners when the component is unmounted.
-     * @param el
-     * @param binding
-     */
-    unmounted(el: ClickOutsideHTMLElement, binding: ClickOutsideBinding): void;
-};
+export declare function variantModifier(value: string, exclude?: (string | RegExp)[]): string | undefined;
+
+export declare type VariantProp = (typeof Variant)[keyof typeof Variant];
 
 declare interface VeilEvents {
     onMouseenter?: () => void;
@@ -22308,6 +23343,8 @@ declare type VerticalSide = "top" | "bottom";
 /** Visibility props */
 declare type VisibilityRuleProp = DisplayRuleListProp | boolean;
 
+export declare let VueInstance: App;
+
 export declare type WindowProvide = {
     transition: ComputedRef<undefined | string>;
     transitionCount: Ref<number>;
@@ -22316,6 +23353,12 @@ export declare type WindowProvide = {
     rootRef: Ref<HTMLElement | undefined>;
 };
 
+/**
+ * # Wrap In Array
+ * @param value
+ */
+export declare function wrapInArray<T>(value: T | null | undefined): T extends readonly any[] ? IfAny<T, T[], T> : NonNullable<T>[];
+
 export { }