@gradient-ui/core 0.5.0-rc.0 → 0.8.0

package/dist/types/use/gradientMaterial.d.ts

@@ -17,5 +17,5 @@ export interface UseGradientMaterialOptions {
 }
 export declare const useGradientMaterial: (options?: UseGradientMaterialOptions) => {
     gradientMaterial: import("vue").ComputedRef<CreatedGradientMaterial | null>;
-    gradientMaterialStyles: import("vue").ComputedRef<CSSProperties>;
+    gradientMaterialStyles: import("vue").ComputedRef<CSSProperties | undefined>;
 };

package/dist/types/use/index.d.ts

@@ -2,6 +2,8 @@ export * from './breakpoints';
 export * from './color';
 export * from './colorResolver';
 export * from './defaults';
+export * from './density';
+export * from './form/fieldKeyboard';
 export * from './gradientMaterial';
 export * from './glass';
 export * from './gradientRuntime';
@@ -10,4 +12,11 @@ export * from './icon';
 export * from './mask';
 export * from './material';
 export * from './materialSurface';
+export * from './navigation';
+export * from './select/commit';
+export * from './select/listboxKeyboard';
+export * from './select/searchFieldControl';
+export * from './select/tokenInputKeyboard';
+export * from './stateIcon';
+export * from './stepper';
 export * from './tagName';

package/dist/types/use/input/props.d.ts

@@ -13,6 +13,9 @@ export declare const makeInputProps: <Defaults extends {
     label?: unknown;
     prependIcon?: unknown;
     appendIcon?: unknown;
+    borderWidth?: unknown;
+    backdropBlur?: unknown;
+    variant?: unknown;
     color?: unknown;
     disabled?: unknown;
 } = object>(defaults?: Defaults | undefined) => {
@@ -100,6 +103,42 @@ export declare const makeInputProps: <Defaults extends {
         type: PropType<Defaults["appendIcon"] extends infer T_22 ? T_22 extends Defaults["appendIcon"] ? T_22 extends unknown ? import("../../types/CommonTypes").MdiIcon : import("../../types/CommonTypes").MdiIcon | T_22 : never : never>;
         default: Defaults["appendIcon"] extends infer T_23 ? T_23 extends Defaults["appendIcon"] ? T_23 extends unknown ? import("../../types/CommonTypes").MdiIcon : NonNullable<import("../../types/CommonTypes").MdiIcon> | T_23 : never : never;
     };
+    borderWidth: Omit<Omit<{
+        type: PropType<import("../../types/CommonTypes").StringeredNumber>;
+        default: import("../../types/CommonTypes").StringeredNumber;
+    }, "type" | "default"> & {
+        type: PropType<import("../../types/CommonTypes").StringeredNumber>;
+        default: import("../../types/CommonTypes").StringeredNumber;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["borderWidth"] extends infer T_24 ? T_24 extends Defaults["borderWidth"] ? T_24 extends unknown ? import("../../types/CommonTypes").StringeredNumber : import("../../types/CommonTypes").StringeredNumber | T_24 : never : never>;
+        default: Defaults["borderWidth"] extends infer T_25 ? T_25 extends Defaults["borderWidth"] ? T_25 extends unknown ? import("../../types/CommonTypes").StringeredNumber : NonNullable<import("../../types/CommonTypes").StringeredNumber> | T_25 : never : never;
+    };
+    backdropBlur: Omit<Omit<Omit<{
+        type: PropType<import("../../types/CommonTypes").StringeredNumber>;
+        default: number;
+    }, "type" | "default"> & {
+        type: PropType<import("../../types/CommonTypes").StringeredNumber>;
+        default: import("../../types/CommonTypes").StringeredNumber;
+    }, "type" | "default"> & {
+        type: PropType<import("../../types/CommonTypes").StringeredNumber>;
+        default: import("../../types/CommonTypes").StringeredNumber;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["backdropBlur"] extends infer T_26 ? T_26 extends Defaults["backdropBlur"] ? T_26 extends unknown ? import("../../types/CommonTypes").StringeredNumber : import("../../types/CommonTypes").StringeredNumber | T_26 : never : never>;
+        default: Defaults["backdropBlur"] extends infer T_27 ? T_27 extends Defaults["backdropBlur"] ? T_27 extends unknown ? import("../../types/CommonTypes").StringeredNumber : NonNullable<import("../../types/CommonTypes").StringeredNumber> | T_27 : never : never;
+    };
+    variant: Omit<Omit<Omit<{
+        type: PropType<import("@/use/form/props").GFieldVariant>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<import("@/use/form/props").GFieldVariant>;
+        default: import("@/use/form/props").GFieldVariant;
+    }, "type" | "default"> & {
+        type: PropType<import("@/use/form/props").GFieldVariant>;
+        default: import("@/use/form/props").GFieldVariant;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["variant"] extends infer T_28 ? T_28 extends Defaults["variant"] ? T_28 extends unknown ? import("@/use/form/props").GFieldVariant : import("@/use/form/props").GFieldVariant | T_28 : never : never>;
+        default: Defaults["variant"] extends infer T_29 ? T_29 extends Defaults["variant"] ? T_29 extends unknown ? import("@/use/form/props").GFieldVariant : NonNullable<import("@/use/form/props").GFieldVariant> | T_29 : never : never;
+    };
     color: Omit<Omit<Omit<{
         type: PropType<import("..").GColor>;
         default: string;
@@ -110,15 +149,15 @@ export declare const makeInputProps: <Defaults extends {
         type: PropType<import("..").GColor>;
         default: import("..").GColor;
     }, "type" | "default"> & {
-        type: PropType<Defaults["color"] extends infer T_24 ? T_24 extends Defaults["color"] ? T_24 extends unknown ? import("..").GColor : import("..").GColor | T_24 : never : never>;
-        default: Defaults["color"] extends infer T_25 ? T_25 extends Defaults["color"] ? T_25 extends unknown ? import("..").GColor : NonNullable<import("..").GColor> | T_25 : never : never;
+        type: PropType<Defaults["color"] extends infer T_30 ? T_30 extends Defaults["color"] ? T_30 extends unknown ? import("..").GColor : import("..").GColor | T_30 : never : never>;
+        default: Defaults["color"] extends infer T_31 ? T_31 extends Defaults["color"] ? T_31 extends unknown ? import("..").GColor : NonNullable<import("..").GColor> | T_31 : never : never;
     };
     disabled: Omit<{
         type: PropType<boolean>;
         default: boolean;
     }, "type" | "default"> & {
-        type: PropType<Defaults["disabled"] extends infer T_26 ? T_26 extends Defaults["disabled"] ? T_26 extends unknown ? boolean : boolean | T_26 : never : never>;
-        default: Defaults["disabled"] extends infer T_27 ? T_27 extends Defaults["disabled"] ? T_27 extends unknown ? boolean : boolean | T_27 : never : never;
+        type: PropType<Defaults["disabled"] extends infer T_32 ? T_32 extends Defaults["disabled"] ? T_32 extends unknown ? boolean : boolean | T_32 : never : never>;
+        default: Defaults["disabled"] extends infer T_33 ? T_33 extends Defaults["disabled"] ? T_33 extends unknown ? boolean : boolean | T_33 : never : never;
     };
 };
 export type GInputProps = ReturnType<typeof makeInputProps>;

package/dist/types/use/material.d.ts

@@ -1,6 +1,6 @@
 import type { GGradienStates } from '@/components/ui/GGradient/types';
 import type { StringeredNumber } from '@/types/CommonTypes';
-import type { GradientAnimationOptions, GradientMorphBlob, GradientMorphOptions, GradientShadowOptions, GradientTokenRecipe } from '@/theme';
+import type { GradientAnimationOptions, GradientMorphBlob, GradientMorphOptions, GradientMaterialOptions, GradientShadowOptions, GradientTokenRecipe } from '@/theme';
 import type { GColor } from '@/use/color';
 import { type CSSProperties, type MaybeRefOrGetter, type PropType } from 'vue';
 import { type GradientMaterialKind } from './gradientMaterial';
@@ -25,6 +25,7 @@ export interface UseMaterialOptions {
     dropShadow?: MaybeRefOrGetter<GradientShadowOptions | undefined>;
     animation?: MaybeRefOrGetter<GradientAnimationOptions | undefined>;
     morph?: MaybeRefOrGetter<boolean | GradientMorphOptions | undefined>;
+    options?: MaybeRefOrGetter<GradientMaterialOptions | undefined>;
     borderRadius?: MaybeRefOrGetter<StringeredNumber | undefined>;
     padding?: MaybeRefOrGetter<StringeredNumber | undefined>;
 }
@@ -106,7 +107,7 @@ export declare const useMaterial: (options?: UseMaterialOptions) => {
     materialGlowMorphClasses: import("vue").ComputedRef<string[]>;
     materialMorphBlobClasses: import("vue").ComputedRef<string[]>;
     materialMorphClasses: import("vue").ComputedRef<string[]>;
-    materialStyles: import("vue").ComputedRef<CSSProperties>;
+    materialStyles: import("vue").ComputedRef<CSSProperties | undefined>;
     morphBlobs: import("vue").ComputedRef<GradientMorphBlob[]>;
     morphEnabled: import("vue").ComputedRef<boolean>;
 };

package/dist/types/use/materialSurface.d.ts

@@ -1,6 +1,5 @@
 import type { GGradienStates } from '@/components/ui/GGradient/types';
 import type { GradientAnimationOptions, GradientMorphOptions, GradientShadowOptions, GradientTokenRecipe } from '@/theme';
-import { type CSSProperties } from 'vue';
 import type { GColor } from './color';
 import { type GlassProps } from './glass';
 import { type GGlow } from './gradient';
@@ -353,14 +352,21 @@ export declare const useMaterialSurface: (props: MaterialSurfaceProps, baseClass
         state: import("./gradient").GGradienStates | undefined;
         surfaceFill: "transparent";
     }>;
-    surfaceStyles: import("vue").ComputedRef<CSSProperties>;
+    surfaceStyles: import("vue").ComputedRef<(import("vue").CSSProperties | {
+        '--g-glass-backdrop-blur': string;
+    } | undefined)[]>;
     surfaceContentClasses: import("vue").ComputedRef<string[]>;
     surfaceTextureClasses: import("vue").ComputedRef<string[]>;
     surfaceOverlayClasses: import("vue").ComputedRef<string[]>;
     surfaceUnderlayClasses: import("vue").ComputedRef<string[]>;
     surfaceMaterialMorphBlobClasses: import("vue").ComputedRef<string[]>;
     surfaceMaterialMorphClasses: import("vue").ComputedRef<string[]>;
-    getMorphBlobStyle: (blob: import("@gradient-ui/gradient-engine").GradientMorphBlob) => CSSProperties;
+    hasMaterialAnimations: import("vue").ComputedRef<boolean>;
+    hasMaterialEffects: import("vue").ComputedRef<boolean>;
+    hasMaterialSurface: import("vue").ComputedRef<boolean>;
+    hasMorph: import("vue").ComputedRef<boolean>;
+    resolvedMorph: import("vue").ComputedRef<boolean | GradientMorphOptions | undefined>;
+    getMorphBlobStyle: (blob: import("@gradient-ui/gradient-engine").GradientMorphBlob) => import("vue").CSSProperties;
     gradientMaterial: import("vue").ComputedRef<import("@gradient-ui/gradient-engine").CreatedGradientMaterial | null>;
     materialClasses: import("vue").ComputedRef<string[]>;
     materialContentClasses: import("vue").ComputedRef<string[]>;
@@ -370,7 +376,7 @@ export declare const useMaterialSurface: (props: MaterialSurfaceProps, baseClass
     materialGlowMorphClasses: import("vue").ComputedRef<string[]>;
     materialMorphBlobClasses: import("vue").ComputedRef<string[]>;
     materialMorphClasses: import("vue").ComputedRef<string[]>;
-    materialStyles: import("vue").ComputedRef<CSSProperties>;
+    materialStyles: import("vue").ComputedRef<import("vue").CSSProperties | undefined>;
     morphBlobs: import("vue").ComputedRef<import("@gradient-ui/gradient-engine").GradientMorphBlob[]>;
     morphEnabled: import("vue").ComputedRef<boolean>;
 };

package/dist/types/use/navigation/controller.d.ts

@@ -0,0 +1,14 @@
+import type { GNavigationRegistration, GNavigationValue, UseNavigationControllerOptions } from './types';
+export declare function useNavigationController<T = GNavigationValue>(options: UseNavigationControllerOptions<T>): {
+    model: import("vue").WritableComputedRef<T | undefined, T | undefined>;
+    registeredItems: import("vue").ShallowRef<GNavigationRegistration<T>[], GNavigationRegistration<T>[]>;
+    isSelected: (value: T | undefined) => boolean;
+    select: (value: T | undefined, event?: Event) => void;
+    registerItem: (registration: GNavigationRegistration<T>) => void;
+    unregisterItem: (el: HTMLElement) => void;
+    getEnabledItems: () => GNavigationRegistration<T>[];
+    focusItem: (index: number, event: KeyboardEvent) => void;
+    onItemKeydown: (event: KeyboardEvent, value: T | undefined) => void;
+    getItemId: (value: T | undefined) => string;
+    getPanelId: (value: T | undefined) => string;
+};

package/dist/types/use/navigation/index.d.ts

@@ -0,0 +1,4 @@
+export * from './controller';
+export * from './item';
+export * from './keyboard';
+export * from './types';

package/dist/types/use/navigation/item.d.ts

@@ -0,0 +1,9 @@
+import type { GNavigationValue, UseNavigationItemOptions } from './types';
+export declare function useNavigationItem<T = GNavigationValue>(options: UseNavigationItemOptions<T>): {
+    value: import("vue").ComputedRef<T | undefined>;
+    disabled: import("vue").ComputedRef<boolean>;
+    selected: import("vue").ComputedRef<boolean>;
+    select: (nextValue: T | undefined, event?: Event) => void;
+    onClick: (event: MouseEvent) => void;
+    onKeydown: (event: KeyboardEvent) => void;
+};

package/dist/types/use/navigation/keyboard.d.ts

@@ -0,0 +1,4 @@
+import type { UseNavigationKeyboardOptions } from './types';
+export declare function useNavigationKeyboard<T>(options: UseNavigationKeyboardOptions<T>): {
+    onItemKeydown: (event: KeyboardEvent, value: T | undefined) => void;
+};

package/dist/types/use/navigation/types.d.ts

@@ -0,0 +1,42 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+export type GNavigationValue = string | number | boolean | symbol | Record<string, unknown> | unknown[];
+export type GNavigationOrientation = 'horizontal' | 'vertical';
+export interface GNavigationRegistration<T = GNavigationValue> {
+    value: T | undefined;
+    el: HTMLElement;
+    disabled: boolean;
+}
+export interface UseNavigationControllerOptions<T = GNavigationValue> {
+    modelValue: MaybeRefOrGetter<T | undefined>;
+    defaultValue?: MaybeRefOrGetter<T | undefined>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    mandatory?: MaybeRefOrGetter<boolean | undefined>;
+    orientation?: MaybeRefOrGetter<GNavigationOrientation | undefined>;
+    selectOnFocus?: MaybeRefOrGetter<boolean | undefined>;
+    selectOnAction?: MaybeRefOrGetter<boolean | undefined>;
+    idPrefix: string;
+    itemIdSegment?: string;
+    panelIdSegment?: string;
+    onUpdateModelValue: (value: T | undefined) => void;
+    onSelect?: (value: T | undefined, event?: Event) => void;
+    canSelect?: (value: T | undefined, event?: Event) => boolean;
+}
+export interface UseNavigationKeyboardOptions<T = GNavigationValue> {
+    orientation?: MaybeRefOrGetter<GNavigationOrientation | undefined>;
+    selectOnAction?: MaybeRefOrGetter<boolean | undefined>;
+    getEnabledItems: () => GNavigationRegistration<T>[];
+    focusItem: (index: number, event: KeyboardEvent) => void;
+    select: (value: T | undefined, event?: Event) => void;
+}
+export interface UseNavigationItemOptions<T = GNavigationValue> {
+    value: MaybeRefOrGetter<T | undefined>;
+    rootRef: Ref<HTMLElement | null>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    parentDisabled?: MaybeRefOrGetter<boolean | undefined>;
+    isSelected?: (value: T | undefined) => boolean;
+    select?: (value: T | undefined, event?: Event) => void;
+    registerItem?: (registration: GNavigationRegistration<T>) => void;
+    unregisterItem?: (el: HTMLElement) => void;
+    onItemKeydown?: (event: KeyboardEvent, value: T | undefined) => void;
+    onClick?: (event: MouseEvent) => void;
+}

package/dist/types/use/select/comboboxController.d.ts

@@ -0,0 +1,36 @@
+import { type ComboboxItemFromQuery } from './creatable';
+import { type SelectMenuFilter } from './filter';
+import type { GMenuItemBase } from '@/use/menu';
+import type { InternalItem, SelectBaseProps, SelectionValue } from './types';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+export type { ComboboxItemFromQuery } from './creatable';
+export type ComboboxFilter<T, V> = SelectMenuFilter<T, V>;
+type MaybeRefSelectProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = {
+    [K in keyof SelectBaseProps<T, V, Multiple, ReturnObject>]: MaybeRef<SelectBaseProps<T, V, Multiple, ReturnObject>[K]>;
+};
+export interface UseComboboxControllerOptions<T, V, Multiple extends boolean, ReturnObject extends boolean> extends MaybeRefSelectProps<T, V, Multiple, ReturnObject> {
+    search?: MaybeRefOrGetter<string | undefined>;
+    allowCustom?: MaybeRefOrGetter<boolean | undefined>;
+    itemFromQuery?: MaybeRefOrGetter<ComboboxItemFromQuery<T> | undefined>;
+    filter?: MaybeRefOrGetter<ComboboxFilter<T, V> | undefined>;
+    onSearch: (value: string) => void;
+}
+export declare function useComboboxController<T, V, Multiple extends boolean = false, ReturnObject extends boolean = false>(props: UseComboboxControllerOptions<T, V, Multiple, ReturnObject>, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    isMultiple: import("vue").ComputedRef<boolean>;
+    shouldCloseOnSelect: import("vue").ComputedRef<boolean>;
+    searchValue: import("vue").ComputedRef<string>;
+    setSearch: (value: string) => void;
+    filteredMenuItems: import("vue").ComputedRef<import("./menuItems").SelectMenuItem<T, V>[]>;
+    getSlotItem: (item: GMenuItemBase) => import("./menuItems").SelectMenuItem<T, V>;
+    resolveMenuItem: (item: GMenuItemBase) => import("./menuItems").SelectMenuItem<T, V> | undefined;
+    isItemSelected: (item: InternalItem<T, V>) => boolean;
+    isMenuItemSelected: (item: GMenuItemBase) => boolean;
+    isCustomItem: (item: InternalItem<T, V>) => boolean;
+    isCustomMenuItem: (item: GMenuItemBase) => boolean;
+    customSelectionItem: import("vue").ComputedRef<InternalItem<T, V> | undefined>;
+    firstVisibleItem: () => import("./menuItems").SelectMenuItem<T, V> | undefined;
+    selectItem: (item: InternalItem<T, V>) => void;
+    selectedItems: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    hasSelection: import("vue").ComputedRef<boolean>;
+    selectionText: import("vue").ComputedRef<string>;
+};

package/dist/types/use/select/commit.d.ts

@@ -0,0 +1,23 @@
+import { type MaybeRefOrGetter, type Ref } from 'vue';
+import type { GMenuItemBase } from '@/use/menu';
+import type { InternalItem } from './types';
+export interface UseSelectCommitOptions<T, V> {
+    open: Ref<boolean>;
+    isMultiple: MaybeRefOrGetter<boolean>;
+    shouldCloseOnSelect: MaybeRefOrGetter<boolean>;
+    searchValue: MaybeRefOrGetter<string>;
+    resolveMenuItem: (item: GMenuItemBase) => InternalItem<T, V> | undefined;
+    firstVisibleItem: () => InternalItem<T, V> | undefined;
+    selectItem: (item: InternalItem<T, V>) => void;
+    setSearch: (value: string) => void;
+    onInputValidation: () => void;
+    isCustomItem?: (item: InternalItem<T, V>) => boolean;
+    onAdd?: (item: T, query: string) => void;
+    onSelect?: (item: InternalItem<T, V>) => void;
+}
+export declare function useSelectCommit<T, V>(options: UseSelectCommitOptions<T, V>): {
+    commitItem: (item: InternalItem<T, V>) => void;
+    onSelect: (item: GMenuItemBase) => void;
+    selectFirstVisibleItem: () => void;
+    removeItem: (item: InternalItem<T, V>) => void;
+};

package/dist/types/use/select/controller.d.ts

@@ -6,11 +6,16 @@ type MaybeRefSelectProps<T, V, Multiple extends boolean, ReturnObject extends bo
 };
 export declare function useSelectController<T, V, Multiple extends boolean = false, ReturnObject extends boolean = false>(props: MaybeRefSelectProps<T, V, Multiple, ReturnObject>, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
     isMultiple: import("vue").ComputedRef<boolean>;
+    isReturnObject: import("vue").ComputedRef<boolean>;
     shouldCloseOnSelect: import("vue").ComputedRef<boolean>;
+    normalizedItems: import("vue").ComputedRef<import("./types").InternalItem<T, V>[]>;
     menuItems: import("vue").ComputedRef<import("./menuItems").SelectMenuItem<T, V>[]>;
     resolveMenuItem: (item: GMenuItemBase) => import("./menuItems").SelectMenuItem<T, V> | undefined;
+    getSlotItem: (item: GMenuItemBase) => import("./menuItems").SelectMenuItem<T, V>;
+    isItemSelected: (item: import("./types").InternalItem<T, V>) => boolean;
     isMenuItemSelected: (item: GMenuItemBase) => boolean;
     handleSelect: (item: GMenuItemBase, onClose?: () => void) => void;
+    selectItem: (item: import("./types").InternalItem<T, V>) => void;
     selectedItems: import("vue").ComputedRef<import("./types").InternalItem<T, V>[]>;
     hasSelection: import("vue").ComputedRef<boolean>;
     selectionText: import("vue").ComputedRef<string>;

package/dist/types/use/select/creatable.d.ts

@@ -0,0 +1,18 @@
+import type { InternalItem, SelectBaseProps } from './types';
+import type { MaybeRef, MaybeRefOrGetter } from 'vue';
+export type ComboboxItemFromQuery<T> = (query: string) => T;
+type MaybeRefItemKeyProps<T, V> = Pick<{
+    [K in keyof SelectBaseProps<T, V>]: MaybeRef<SelectBaseProps<T, V>[K]>;
+}, 'labelKey' | 'valueKey'>;
+export interface UseComboboxCreatableOptions<T, V> extends MaybeRefItemKeyProps<T, V> {
+    searchValue: MaybeRefOrGetter<string>;
+    normalizedQuery: MaybeRefOrGetter<string>;
+    normalizedSourceItems: MaybeRefOrGetter<readonly InternalItem<T, V>[]>;
+    allowCustom?: MaybeRefOrGetter<boolean | undefined>;
+    itemFromQuery?: MaybeRefOrGetter<ComboboxItemFromQuery<T> | undefined>;
+    createRawRecord: (label: string, value: unknown) => T;
+}
+export declare function useComboboxCreatable<T, V>(options: UseComboboxCreatableOptions<T, V>): {
+    customItem: import("vue").ComputedRef<T | undefined>;
+};
+export {};

package/dist/types/use/select/fieldControl.d.ts

@@ -0,0 +1,59 @@
+import type { MdiIcon, Sizes } from '@/types/CommonTypes';
+import type { GGradienStates } from '@/components/ui/GGradient/types';
+import type { GColor } from '@/use/color';
+import type { GlassProps } from '@/use/glass';
+import type { ValidationRule } from 'gib-validate';
+import type { MaybeRefOrGetter } from 'vue';
+import type { GFieldVariant } from '@/use/form/props';
+import type { StringeredNumber } from '@/types/CommonTypes';
+export interface UseSelectFieldControlOptions<TModel> {
+    id: MaybeRefOrGetter<string>;
+    modelValue: MaybeRefOrGetter<TModel>;
+    rules: MaybeRefOrGetter<ValidationRule<TModel>[] | undefined>;
+    message: MaybeRefOrGetter<string | undefined>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    label?: MaybeRefOrGetter<string | undefined>;
+    color?: MaybeRefOrGetter<GColor | undefined>;
+    variant?: MaybeRefOrGetter<GFieldVariant | undefined>;
+    backdropBlur?: MaybeRefOrGetter<GlassProps['backdropBlur']>;
+    borderWidth?: MaybeRefOrGetter<StringeredNumber | undefined>;
+    state?: MaybeRefOrGetter<GGradienStates | undefined>;
+    clearable?: MaybeRefOrGetter<boolean | undefined>;
+    size?: MaybeRefOrGetter<Sizes | undefined>;
+    focused?: MaybeRefOrGetter<boolean | undefined>;
+    hasValue: MaybeRefOrGetter<boolean>;
+    prependIcon?: MaybeRefOrGetter<MdiIcon | undefined>;
+    appendIcon?: MaybeRefOrGetter<MdiIcon | undefined>;
+    multiline?: MaybeRefOrGetter<boolean | undefined>;
+}
+export declare function useSelectFieldControl<TModel>(options: UseSelectFieldControlOptions<TModel>): {
+    fieldProps: import("vue").ComputedRef<{
+        id: string;
+        label: string | undefined;
+        color: GColor | undefined;
+        variant: GFieldVariant | undefined;
+        backdropBlur: StringeredNumber | undefined;
+        borderWidth: StringeredNumber | undefined;
+        state: GGradienStates | undefined;
+        disabled: boolean;
+        clearable: boolean | undefined;
+        size: Sizes | undefined;
+        focused: boolean;
+        message: string;
+        prependIcon: MdiIcon | undefined;
+        appendIcon: MdiIcon | undefined;
+        hasValue: boolean;
+        multiline: boolean;
+    }>;
+    focused: import("vue").Ref<boolean, boolean>;
+    $v: import("gib-validate").ValidationResult<{
+        modelValue: import("gib-validate").Validatable;
+    }>;
+    disabled: import("vue").ComputedRef<boolean>;
+    validateOn: import("vue").ComputedRef<import("../form/context").GFormValidateOn>;
+    computedMessage: import("vue").ComputedRef<string>;
+    hasValidationError: import("vue").ComputedRef<boolean>;
+    onFocus: () => void;
+    onBlur: () => void;
+    onInputValidation: () => void;
+};

package/dist/types/use/select/filter.d.ts

@@ -0,0 +1,14 @@
+import type { SelectMenuItem } from './menuItems';
+import type { MaybeRefOrGetter } from 'vue';
+export type SelectMenuFilter<T, V> = (item: SelectMenuItem<T, V>, query: string) => boolean;
+export interface UseFilteredSelectMenuOptions<T, V> {
+    items: MaybeRefOrGetter<readonly SelectMenuItem<T, V>[]>;
+    searchValue: MaybeRefOrGetter<string>;
+    normalizedQuery: MaybeRefOrGetter<string>;
+    filter?: MaybeRefOrGetter<SelectMenuFilter<T, V> | undefined>;
+    isAlwaysVisible?: (item: SelectMenuItem<T, V>) => boolean;
+}
+export declare function useFilteredSelectMenu<T, V>(options: UseFilteredSelectMenuOptions<T, V>): {
+    filteredMenuItems: import("vue").ComputedRef<SelectMenuItem<T, V>[]>;
+    firstVisibleItem: import("vue").ComputedRef<SelectMenuItem<T, V> | undefined>;
+};

package/dist/types/use/select/listboxKeyboard.d.ts

@@ -0,0 +1,9 @@
+import type { Ref } from 'vue';
+import type { FieldKeyboardHandler } from '@/use/form/fieldKeyboard';
+export interface UseSelectListboxKeyboardOptions {
+    open: Ref<boolean>;
+    selectFirstVisibleItem: () => void;
+}
+export declare function useSelectListboxKeyboard(options: UseSelectListboxKeyboardOptions): {
+    handlers: readonly FieldKeyboardHandler[];
+};

package/dist/types/use/select/modelFallbackItems.d.ts

@@ -0,0 +1,12 @@
+import type { SelectBaseProps } from './types';
+import type { MaybeRef } from 'vue';
+type MaybeRefSelectProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = Pick<{
+    [K in keyof SelectBaseProps<T, V, Multiple, ReturnObject>]: MaybeRef<SelectBaseProps<T, V, Multiple, ReturnObject>[K]>;
+}, 'items' | 'modelValue' | 'labelKey' | 'valueKey' | 'itemChildren' | 'returnObject'>;
+export type UseModelFallbackItemsOptions<T, V, Multiple extends boolean, ReturnObject extends boolean> = MaybeRefSelectProps<T, V, Multiple, ReturnObject>;
+export declare function useModelFallbackItems<T, V, Multiple extends boolean, ReturnObject extends boolean>(options: UseModelFallbackItemsOptions<T, V, Multiple, ReturnObject>): {
+    sourceItems: import("vue").ComputedRef<readonly T[]>;
+    normalizedSourceItems: import("vue").ComputedRef<import("./types").InternalItem<T, V>[]>;
+    createRawRecord: (label: string, value: unknown) => T;
+};
+export {};

package/dist/types/use/select/search.d.ts

@@ -0,0 +1,14 @@
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+export interface UseSelectSearchOptions {
+    search?: MaybeRefOrGetter<string | undefined>;
+    selectionText?: ComputedRef<string>;
+    isMultiple?: MaybeRefOrGetter<boolean>;
+    onSearch: (value: string) => void;
+}
+export declare const normalizeSelectSearch: (value: string) => string;
+export declare function useSelectSearch(options: UseSelectSearchOptions): {
+    searchValue: ComputedRef<string>;
+    normalizedQuery: ComputedRef<string>;
+    setSearch: (value: string) => void;
+    syncSelectionText: (selectionText: ComputedRef<string>, isMultiple: MaybeRefOrGetter<boolean>) => void;
+};

package/dist/types/use/select/searchFieldControl.d.ts

@@ -0,0 +1,24 @@
+import type { MaybeRefOrGetter, Ref } from 'vue';
+export interface UseSearchFieldControlOptions {
+    open: Ref<boolean>;
+    inputRef: Ref<HTMLInputElement | undefined>;
+    disabled: MaybeRefOrGetter<boolean | undefined>;
+    setSearch: (value: string) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    onInputValidation: () => void;
+    emitFocus: (event: FocusEvent) => void;
+    emitBlur: (event: FocusEvent) => void;
+    emitClear: () => void;
+    clearValue: () => void;
+    afterBlur?: () => void;
+    activatorIgnoreSelector?: string;
+}
+export declare function useSearchFieldControl(options: UseSearchFieldControlOptions): {
+    handleInput: (event: Event) => void;
+    handleFocus: (event: FocusEvent) => void;
+    handleBlur: (event: FocusEvent) => void;
+    handleClear: () => void;
+    focusControl: () => void;
+    handleActivatorMousedown: (event: MouseEvent) => void;
+};

package/dist/types/use/select/selectionSummary.d.ts

@@ -1,5 +1,6 @@
 import { type ComputedRef, type Ref } from 'vue';
 import type { InternalItem } from './types';
+export declare function flattenSelectItems<T, V>(items: readonly InternalItem<T, V>[]): InternalItem<T, V>[];
 export declare function useSelectionSummary<T, V>(items: Ref<InternalItem<T, V>[]>, isItemSelected: (item: InternalItem<T, V>) => boolean): {
     selectedItems: ComputedRef<InternalItem<T, V>[]>;
     hasSelection: ComputedRef<boolean>;

package/dist/types/use/select/tokenInputKeyboard.d.ts

@@ -0,0 +1,11 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { FieldKeyboardHandler } from '@/use/form/fieldKeyboard';
+export interface UseTokenInputKeyboardOptions<T> {
+    enabled?: MaybeRefOrGetter<boolean | undefined>;
+    searchValue: MaybeRefOrGetter<string>;
+    items: MaybeRefOrGetter<readonly T[]>;
+    removeItem: (item: T) => void;
+}
+export declare function useTokenInputKeyboard<T>(options: UseTokenInputKeyboardOptions<T>): {
+    handlers: readonly FieldKeyboardHandler[];
+};

package/dist/types/use/stateIcon.d.ts

@@ -0,0 +1,9 @@
+import type { MdiIcon } from '@/types/CommonTypes';
+export type GStateIconMap<TState extends string> = Partial<Record<TState, MdiIcon>>;
+export interface ResolveStateIconOptions<TState extends string> {
+    state: TState;
+    icon?: MdiIcon;
+    icons?: GStateIconMap<TState>;
+    defaultIcons?: GStateIconMap<TState>;
+}
+export declare const resolveStateIcon: <TState extends string>({ state, icon, icons, defaultIcons }: ResolveStateIconOptions<TState>) => MdiIcon | undefined;

package/dist/types/use/stepper/controller.d.ts

@@ -0,0 +1,20 @@
+import { type MaybeRefOrGetter } from 'vue';
+import type { GStepValue, GStepperActivation, GStepperItem, GStepperOrientation, GStepperResolvedItem } from '@/components/ui/GStepper/types';
+export interface UseStepperControllerOptions<T = unknown, V = GStepValue> {
+    items: MaybeRefOrGetter<readonly GStepperItem<T, V>[] | undefined>;
+    modelValue: MaybeRefOrGetter<V | undefined>;
+    defaultValue?: MaybeRefOrGetter<V | undefined>;
+    disabled?: MaybeRefOrGetter<boolean | undefined>;
+    mandatory?: MaybeRefOrGetter<boolean | undefined>;
+    linear?: MaybeRefOrGetter<boolean | undefined>;
+    editable?: MaybeRefOrGetter<boolean | undefined>;
+    activation?: MaybeRefOrGetter<GStepperActivation | undefined>;
+    orientation?: MaybeRefOrGetter<GStepperOrientation | undefined>;
+    idPrefix: string;
+    onUpdateModelValue: (value: V | undefined) => void;
+    onSelect?: (value: V | undefined, item: GStepperResolvedItem<T, V> | undefined, event?: Event) => void;
+    onNext?: (value: V | undefined, item: GStepperResolvedItem<T, V> | undefined, event?: Event) => void;
+    onPrev?: (value: V | undefined, item: GStepperResolvedItem<T, V> | undefined, event?: Event) => void;
+    onFinish?: (value: V | undefined, item: GStepperResolvedItem<T, V> | undefined, event?: Event) => void;
+}
+export declare function useStepperController<T = unknown, V = GStepValue>(options: UseStepperControllerOptions<T, V>): any;

package/dist/types/use/stepper/index.d.ts

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

package/dist/types/use/surfaceColor.d.ts

@@ -14,5 +14,6 @@ export declare function useSurfaceColor(props: SurfaceColorProps): {
     resolvedGradient: import("vue").ComputedRef<string>;
     colorStyles: import("vue").ComputedRef<CSSProperties>;
     surfaceColorStyles: import("vue").ComputedRef<CSSProperties>;
-    gradientStyles: import("vue").ComputedRef<CSSProperties>;
+    gradientCurrentStyles: import("vue").ComputedRef<CSSProperties>;
+    gradientStyles: import("vue").ComputedRef<CSSProperties[]>;
 };

package/dist/types/use/surfaceMaterial.d.ts

@@ -0,0 +1,45 @@
+import type { GradientAnimationOptions, GradientMorphOptions, GradientShadowOptions, GradientTokenRecipe } from '@/theme';
+import type { GGradienStates } from '@/components/ui/GGradient/types';
+import type { GColor } from './color';
+import { type MaybeRefOrGetter } from 'vue';
+import { type UseMaterialOptions } from './material';
+import type { GradientMaterialKind } from './gradientMaterial';
+export interface SurfaceMaterialProps {
+    gradientRecipe?: MaybeRefOrGetter<GradientTokenRecipe | undefined>;
+    shadow?: MaybeRefOrGetter<boolean | undefined>;
+    dropShadow?: MaybeRefOrGetter<boolean | undefined>;
+    morph?: MaybeRefOrGetter<boolean | undefined>;
+    shadowOptions?: MaybeRefOrGetter<GradientShadowOptions | undefined>;
+    dropShadowOptions?: MaybeRefOrGetter<GradientShadowOptions | undefined>;
+    animationOptions?: MaybeRefOrGetter<GradientAnimationOptions | undefined>;
+    morphOptions?: MaybeRefOrGetter<GradientMorphOptions | undefined>;
+}
+export interface UseSurfaceMaterialOptions {
+    baseClass?: string;
+    color?: MaybeRefOrGetter<GColor | GGradienStates | undefined>;
+    state?: MaybeRefOrGetter<GGradienStates | undefined>;
+    kind?: MaybeRefOrGetter<GradientMaterialKind | undefined>;
+    variant?: MaybeRefOrGetter<string | undefined>;
+    morphScope?: 'always' | 'gradient';
+    options?: UseMaterialOptions['options'];
+}
+export declare const useSurfaceMaterial: (props: SurfaceMaterialProps, options: UseSurfaceMaterialOptions) => {
+    hasMaterialAnimations: import("vue").ComputedRef<boolean>;
+    hasMaterialEffects: import("vue").ComputedRef<boolean>;
+    hasMaterialSurface: import("vue").ComputedRef<boolean>;
+    hasMorph: import("vue").ComputedRef<boolean>;
+    resolvedMorph: import("vue").ComputedRef<boolean | GradientMorphOptions | undefined>;
+    getMorphBlobStyle: (blob: import("@gradient-ui/gradient-engine").GradientMorphBlob) => import("vue").CSSProperties;
+    gradientMaterial: import("vue").ComputedRef<import("@gradient-ui/gradient-engine").CreatedGradientMaterial | null>;
+    materialClasses: import("vue").ComputedRef<string[]>;
+    materialContentClasses: import("vue").ComputedRef<string[]>;
+    materialGlowBaseClasses: import("vue").ComputedRef<string[]>;
+    materialGlowClasses: import("vue").ComputedRef<string[]>;
+    materialGlowMorphBlobClasses: import("vue").ComputedRef<string[]>;
+    materialGlowMorphClasses: import("vue").ComputedRef<string[]>;
+    materialMorphBlobClasses: import("vue").ComputedRef<string[]>;
+    materialMorphClasses: import("vue").ComputedRef<string[]>;
+    materialStyles: import("vue").ComputedRef<import("vue").CSSProperties | undefined>;
+    morphBlobs: import("vue").ComputedRef<import("@gradient-ui/gradient-engine").GradientMorphBlob[]>;
+    morphEnabled: import("vue").ComputedRef<boolean>;
+};