@gradient-ui/core 0.2.0

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

@@ -0,0 +1,23 @@
+import type { GBorderRadius } from '@/use/gradient';
+import { type ExtractPropTypes, type PropType } from 'vue';
+export declare const makeGradientSurfaceProps: <Defaults extends {
+    borderRadius?: unknown;
+    inheritWidth?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    borderRadius: Omit<{
+        type: PropType<GBorderRadius>;
+        default: number;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["borderRadius"] extends infer T ? T extends Defaults["borderRadius"] ? T extends unknown ? GBorderRadius : GBorderRadius | T : never : never>;
+        default: Defaults["borderRadius"] extends infer T_1 ? T_1 extends Defaults["borderRadius"] ? T_1 extends unknown ? GBorderRadius : T_1 | NonNullable<GBorderRadius> : never : never;
+    };
+    inheritWidth: {
+        type: PropType<Defaults["inheritWidth"] extends infer T_2 ? T_2 extends Defaults["inheritWidth"] ? T_2 extends unknown ? boolean : boolean | T_2 : never : never>;
+        default: Defaults["inheritWidth"] extends infer T_3 ? T_3 extends Defaults["inheritWidth"] ? T_3 extends unknown ? boolean : boolean | T_3 : never : never;
+    };
+};
+type GGradientSurfaceProps = ExtractPropTypes<ReturnType<typeof makeGradientSurfaceProps>>;
+export declare function useGradientSurface(props: GGradientSurfaceProps): {
+    surfaceBorderRadius: import("vue").ComputedRef<string>;
+};
+export {};

package/dist/types/use/group/di.d.ts

@@ -0,0 +1,5 @@
+import { type InjectionKey } from 'vue';
+import type { GroupContext } from './types';
+export declare const GroupKey: InjectionKey<unknown>;
+export declare function provideGroup<T>(ctx: GroupContext<T>): void;
+export declare function useGroupInject<T>(): GroupContext<T> | null;

package/dist/types/use/group/groupController.d.ts

@@ -0,0 +1,10 @@
+import { type Ref } from 'vue';
+import type { GroupContext, GroupMode, GroupModel } from './types';
+type GroupControllerOptions<T> = {
+    modelValue: Ref<GroupModel<T>>;
+    mode: Ref<GroupMode>;
+    onChange: (val: GroupModel<T>) => void;
+    activeClass: Ref<string | undefined>;
+};
+export declare function useGroupController<T>({ modelValue, mode, onChange, activeClass }: GroupControllerOptions<T>): GroupContext<T>;
+export {};

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

@@ -0,0 +1,9 @@
+export type GroupMode = 'single' | 'multiple';
+export type GroupModel<T> = T | T[] | null;
+export interface GroupContext<T> {
+    isSelected: (item: T) => boolean;
+    select: (item: T) => void;
+    unselect: (item: T) => void;
+    toggle: (item: T) => void;
+    activeClass: string | undefined;
+}

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

@@ -0,0 +1,12 @@
+import { type PropType } from 'vue';
+export declare const makeHighlightedProps: <Defaults extends {
+    highlighted?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    highlighted: {
+        type: PropType<Defaults["highlighted"] extends infer T ? T extends Defaults["highlighted"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["highlighted"] extends infer T_1 ? T_1 extends Defaults["highlighted"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+};
+export declare function useHighlighted(props: {
+    highlighted: boolean;
+}, base: string): import("vue").ComputedRef<string>;

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

@@ -0,0 +1,22 @@
+import { type App, type Component } from 'vue';
+export interface IconSetComponentProps {
+    icon: string;
+    tag?: string;
+}
+export interface IconSet {
+    component: Component;
+}
+export interface IconsOptions {
+    defaultSet: string;
+    aliases: Record<string, string>;
+    sets: Record<string, IconSet>;
+}
+export interface ResolvedIcon {
+    icon: string;
+    component: Component;
+}
+export declare function createIcons(options?: Partial<IconsOptions>): IconsOptions;
+export declare function provideIcons(options?: Partial<IconsOptions>): void;
+export declare function installIcons(app: App, options?: Partial<IconsOptions>): void;
+export declare function useIcons(): IconsOptions;
+export declare function useIcon(icon: () => string | null | undefined): import("vue").ComputedRef<ResolvedIcon>;

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

@@ -0,0 +1,4 @@
+export * from './breakpoints';
+export * from './defaults';
+export * from './icon';
+export * from './mask';

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

@@ -0,0 +1,10 @@
+import { type Ref } from 'vue';
+import type { InputTypeHTMLAttribute } from 'vue';
+export interface UseInputControlOptions {
+    type: Ref<InputTypeHTMLAttribute | undefined>;
+}
+export declare function useInputControl(options: UseInputControlOptions): {
+    passwordVisible: Ref<boolean, boolean>;
+    computedType: import("vue").ComputedRef<InputTypeHTMLAttribute | undefined>;
+    togglePasswordVisibility: () => void;
+};

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

@@ -0,0 +1,8 @@
+export declare const GInputEmits: {
+    focus: (_event: FocusEvent) => boolean;
+    blur: (_event: FocusEvent) => boolean;
+    input: (_value: string, _event: Event) => boolean;
+    change: (_value: string, _event: Event) => boolean;
+    clear: () => boolean;
+    'toggle-password': (_visible: boolean) => boolean;
+};

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

@@ -0,0 +1,4 @@
+export { makeInputProps } from './props';
+export { GInputEmits } from './emits';
+export { useInputControl } from './control';
+export type { GInputProps } from './props';

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

@@ -0,0 +1,124 @@
+import type { GMaskTokens, GMaskValue } from '@/use/mask';
+import type { InputTypeHTMLAttribute, PropType } from 'vue';
+export declare const makeInputProps: <Defaults extends {
+    clearable?: unknown;
+    mask?: unknown;
+    maskTokens?: unknown;
+    returnMaskedValue?: unknown;
+    type?: unknown;
+    rules?: unknown;
+    size?: unknown;
+    state?: unknown;
+    message?: unknown;
+    label?: unknown;
+    prependIcon?: unknown;
+    appendIcon?: unknown;
+    color?: unknown;
+    disabled?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    clearable: {
+        type: PropType<Defaults["clearable"] extends infer T ? T extends Defaults["clearable"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["clearable"] extends infer T_1 ? T_1 extends Defaults["clearable"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+    mask: {
+        type: PropType<Defaults["mask"] extends infer T_2 ? T_2 extends Defaults["mask"] ? T_2 extends unknown ? GMaskValue : GMaskValue | T_2 : never : never>;
+        default: Defaults["mask"] extends infer T_3 ? T_3 extends Defaults["mask"] ? T_3 extends unknown ? GMaskValue : T_3 | NonNullable<GMaskValue> : never : never;
+    };
+    maskTokens: {
+        type: PropType<Defaults["maskTokens"] extends infer T_4 ? T_4 extends Defaults["maskTokens"] ? T_4 extends unknown ? GMaskTokens : GMaskTokens | T_4 : never : never>;
+        default: Defaults["maskTokens"] extends infer T_5 ? T_5 extends Defaults["maskTokens"] ? T_5 extends unknown ? GMaskTokens : GMaskTokens | T_5 : never : never;
+    };
+    returnMaskedValue: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["returnMaskedValue"] extends infer T_6 ? T_6 extends Defaults["returnMaskedValue"] ? T_6 extends unknown ? boolean : boolean | T_6 : never : never>;
+        default: Defaults["returnMaskedValue"] extends infer T_7 ? T_7 extends Defaults["returnMaskedValue"] ? T_7 extends unknown ? boolean : boolean | T_7 : never : never;
+    };
+    type: Omit<{
+        type: PropType<InputTypeHTMLAttribute>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["type"] extends infer T_8 ? T_8 extends Defaults["type"] ? T_8 extends unknown ? InputTypeHTMLAttribute : InputTypeHTMLAttribute | T_8 : never : never>;
+        default: Defaults["type"] extends infer T_9 ? T_9 extends Defaults["type"] ? T_9 extends unknown ? InputTypeHTMLAttribute : string | T_9 : never : never;
+    };
+    rules: Omit<Omit<{
+        type: PropType<import("gib-validate").ValidationRule<string>[]>;
+        default: () => never[];
+    }, "type" | "default"> & {
+        type: PropType<import("gib-validate").ValidationRule<string>[]>;
+        default: import("gib-validate").ValidationRule<string>[];
+    }, "type" | "default"> & {
+        type: PropType<Defaults["rules"] extends infer T_10 ? T_10 extends Defaults["rules"] ? T_10 extends unknown ? import("gib-validate").ValidationRule<string>[] : import("gib-validate").ValidationRule<string>[] | T_10 : never : never>;
+        default: Defaults["rules"] extends infer T_11 ? T_11 extends Defaults["rules"] ? T_11 extends unknown ? import("gib-validate").ValidationRule<string>[] : import("gib-validate").ValidationRule<string>[] | T_11 : never : never;
+    };
+    size: Omit<Omit<Omit<{
+        type: PropType<import("../../types/CommonTypes").Sizes>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<import("../../types/CommonTypes").Sizes>;
+        default: import("../../types/CommonTypes").Sizes;
+    }, "type" | "default"> & {
+        type: PropType<import("../../types/CommonTypes").Sizes>;
+        default: import("../../types/CommonTypes").Sizes;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["size"] extends infer T_12 ? T_12 extends Defaults["size"] ? T_12 extends unknown ? import("../../types/CommonTypes").Sizes : import("../../types/CommonTypes").Sizes | T_12 : never : never>;
+        default: Defaults["size"] extends infer T_13 ? T_13 extends Defaults["size"] ? T_13 extends unknown ? import("../../types/CommonTypes").Sizes : NonNullable<import("../../types/CommonTypes").Sizes> | T_13 : never : never;
+    };
+    state: Omit<{
+        type: PropType<import("../../components/ui/GGradient/types").GGradienStates>;
+        default: import("../../components/ui/GGradient/types").GGradienStates;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["state"] extends infer T_14 ? T_14 extends Defaults["state"] ? T_14 extends unknown ? import("../../components/ui/GGradient/types").GGradienStates : import("../../components/ui/GGradient/types").GGradienStates | T_14 : never : never>;
+        default: Defaults["state"] extends infer T_15 ? T_15 extends Defaults["state"] ? T_15 extends unknown ? import("../../components/ui/GGradient/types").GGradienStates : NonNullable<import("../../components/ui/GGradient/types").GGradienStates> | T_15 : never : never;
+    };
+    message: Omit<{
+        type: PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["message"] extends infer T_16 ? T_16 extends Defaults["message"] ? T_16 extends unknown ? string : string | T_16 : never : never>;
+        default: Defaults["message"] extends infer T_17 ? T_17 extends Defaults["message"] ? T_17 extends unknown ? string : string | T_17 : never : never;
+    };
+    label: Omit<{
+        type: PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["label"] extends infer T_18 ? T_18 extends Defaults["label"] ? T_18 extends unknown ? string : string | T_18 : never : never>;
+        default: Defaults["label"] extends infer T_19 ? T_19 extends Defaults["label"] ? T_19 extends unknown ? string : string | T_19 : never : never;
+    };
+    prependIcon: Omit<{
+        type: PropType<import("../../types/CommonTypes").MdiIcon>;
+        default: import("../../types/CommonTypes").MdiIcon;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["prependIcon"] extends infer T_20 ? T_20 extends Defaults["prependIcon"] ? T_20 extends unknown ? import("../../types/CommonTypes").MdiIcon : import("../../types/CommonTypes").MdiIcon | T_20 : never : never>;
+        default: Defaults["prependIcon"] extends infer T_21 ? T_21 extends Defaults["prependIcon"] ? T_21 extends unknown ? import("../../types/CommonTypes").MdiIcon : NonNullable<import("../../types/CommonTypes").MdiIcon> | T_21 : never : never;
+    };
+    appendIcon: Omit<{
+        type: PropType<import("../../types/CommonTypes").MdiIcon>;
+        default: import("../../types/CommonTypes").MdiIcon;
+    }, "type" | "default"> & {
+        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;
+    };
+    color: Omit<Omit<Omit<{
+        type: PropType<import("../colorResolver").GColor>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<string>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["color"] extends infer T_24 ? T_24 extends Defaults["color"] ? T_24 extends unknown ? string : string | T_24 : never : never>;
+        default: Defaults["color"] extends infer T_25 ? T_25 extends Defaults["color"] ? T_25 extends unknown ? string : string | T_25 : 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;
+    };
+};
+export type GInputProps = ReturnType<typeof makeInputProps>;

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

@@ -0,0 +1,20 @@
+interface UseItemsOptions<T, V> {
+    items: T[];
+    labelKey?: keyof T | ((item: T) => string);
+    valueKey?: keyof T | ((item: T) => V);
+    itemChildren?: keyof T;
+    returnObject?: boolean;
+}
+export interface InternalItem<T, V = unknown> {
+    label: string;
+    value: V;
+    raw: T;
+    disabled?: boolean;
+    children?: InternalItem<T, V>[];
+}
+export declare function useItems<T, V = unknown>(options: UseItemsOptions<T, V>): {
+    items: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    resolveLabel: (item: T) => string;
+    resolveValue: (item: T) => V;
+};
+export {};

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

@@ -0,0 +1,15 @@
+import type { ComputedRef, Ref } from 'vue';
+export type LayerKind = 'floating' | 'overlay';
+interface UseLayerStackOptions {
+    open: Ref<boolean>;
+    base?: number;
+    kind?: LayerKind;
+}
+export declare function useLayerStack(options: UseLayerStackOptions): {
+    id: number;
+    zIndex: Ref<number | undefined, number | undefined>;
+    isTop: ComputedRef<boolean>;
+    isTopOverlay: ComputedRef<boolean>;
+    bringToFront: () => void;
+};
+export {};

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

@@ -0,0 +1,24 @@
+import type { MaybeRefOrGetter } from 'vue';
+export interface GMaskToken {
+    pattern: RegExp;
+    transform?: (value: string) => string;
+}
+export type GMaskTokens = Record<string, GMaskToken>;
+export type GMaskValue = string | string[] | undefined;
+export interface GMaskOptions {
+    mask: MaybeRefOrGetter<GMaskValue>;
+    tokens?: MaybeRefOrGetter<GMaskTokens | undefined>;
+    returnMaskedValue?: MaybeRefOrGetter<boolean | undefined>;
+}
+export declare const defaultMaskTokens: GMaskTokens;
+export declare function applyMask(value: string, mask: GMaskValue, tokens?: GMaskTokens): string;
+export declare function unmaskValue(value: string, tokens?: GMaskTokens): string;
+export declare function useMask(options: GMaskOptions): {
+    isMasked: import("vue").ComputedRef<boolean>;
+    tokens: import("vue").ComputedRef<{
+        [x: string]: GMaskToken;
+    }>;
+    format: (value: string) => string;
+    toModelValue: (value: string) => string;
+    toDisplayValue: (value: string) => string;
+};

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

@@ -0,0 +1,49 @@
+import type { PropType } from 'vue';
+import type { GGradienStates } from './gradient';
+export interface GMenuItemBase {
+    id?: string | number;
+    disabled?: boolean;
+    title?: string;
+    label?: string;
+    value?: unknown;
+    children?: GMenuItemBase[];
+}
+export declare const GMenuEmits: {
+    select: (_item: GMenuItemBase) => boolean;
+    hover: (_item: GMenuItemBase) => boolean;
+};
+export declare const makeGMenuProps: <Defaults extends {
+    items?: unknown;
+    isSelected?: unknown;
+    isHighlighted?: unknown;
+    state?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    items: Omit<{
+        type: PropType<GMenuItemBase[]>;
+        default: () => never[];
+    }, "type" | "default"> & {
+        type: PropType<Defaults["items"] extends infer T ? T extends Defaults["items"] ? T extends unknown ? GMenuItemBase[] : GMenuItemBase[] | T : never : never>;
+        default: Defaults["items"] extends infer T_1 ? T_1 extends Defaults["items"] ? T_1 extends unknown ? GMenuItemBase[] : GMenuItemBase[] | T_1 : never : never;
+    };
+    isSelected: Omit<{
+        type: PropType<(item: GMenuItemBase) => boolean>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["isSelected"] extends infer T_2 ? T_2 extends Defaults["isSelected"] ? T_2 extends unknown ? (item: GMenuItemBase) => boolean : ((item: GMenuItemBase) => boolean) | T_2 : never : never>;
+        default: Defaults["isSelected"] extends infer T_3 ? T_3 extends Defaults["isSelected"] ? T_3 extends unknown ? (item: GMenuItemBase) => boolean : ((item: GMenuItemBase) => boolean) | T_3 : never : never;
+    };
+    isHighlighted: Omit<{
+        type: PropType<(item: GMenuItemBase) => boolean>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["isHighlighted"] extends infer T_4 ? T_4 extends Defaults["isHighlighted"] ? T_4 extends unknown ? (item: GMenuItemBase) => boolean : ((item: GMenuItemBase) => boolean) | T_4 : never : never>;
+        default: Defaults["isHighlighted"] extends infer T_5 ? T_5 extends Defaults["isHighlighted"] ? T_5 extends unknown ? (item: GMenuItemBase) => boolean : ((item: GMenuItemBase) => boolean) | T_5 : never : never;
+    };
+    state: Omit<{
+        type: PropType<GGradienStates>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["state"] extends infer T_6 ? T_6 extends Defaults["state"] ? T_6 extends unknown ? GGradienStates : GGradienStates | T_6 : never : never>;
+        default: Defaults["state"] extends infer T_7 ? T_7 extends Defaults["state"] ? T_7 extends unknown ? GGradienStates : NonNullable<GGradienStates> | T_7 : never : never;
+    };
+};

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

@@ -0,0 +1,6 @@
+import type { GMenuItemBase } from '@/use/menu';
+export interface MenuContextState {
+    onSelect: (item: GMenuItemBase) => void;
+    onHover: (item: GMenuItemBase) => void;
+}
+export declare function useMenuContext(handlers?: Partial<MenuContextState>): MenuContextState;

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

@@ -0,0 +1,2 @@
+import type { GFloatingProps } from './floating';
+export declare const useOpen: (props: GFloatingProps, emit: (event: string, value: boolean) => void) => import("vue").WritableComputedRef<boolean, boolean>;

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

@@ -0,0 +1,111 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+export type OverlayPlacement = 'center' | 'left' | 'right' | 'top' | 'bottom' | 'fullscreen';
+export type OverlayPosition = 'fixed' | 'absolute';
+export declare const makeOverlayProps: <Defaults extends {
+    modelValue?: unknown;
+    defaultOpen?: unknown;
+    appendTo?: unknown;
+    zIndexBase?: unknown;
+    position?: unknown;
+    placement?: unknown;
+    persistent?: unknown;
+    closeOnEsc?: unknown;
+    closeOnOutside?: unknown;
+    lockScroll?: unknown;
+    scrim?: unknown;
+    disabled?: unknown;
+    transition?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    modelValue: Omit<{
+        type: BooleanConstructor;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["modelValue"] extends infer T ? T extends Defaults["modelValue"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["modelValue"] extends infer T_1 ? T_1 extends Defaults["modelValue"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+    defaultOpen: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["defaultOpen"] extends infer T_2 ? T_2 extends Defaults["defaultOpen"] ? T_2 extends unknown ? boolean : boolean | T_2 : never : never>;
+        default: Defaults["defaultOpen"] extends infer T_3 ? T_3 extends Defaults["defaultOpen"] ? T_3 extends unknown ? boolean : boolean | T_3 : never : never;
+    };
+    appendTo: Omit<{
+        type: StringConstructor;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["appendTo"] extends infer T_4 ? T_4 extends Defaults["appendTo"] ? T_4 extends unknown ? string : string | T_4 : never : never>;
+        default: Defaults["appendTo"] extends infer T_5 ? T_5 extends Defaults["appendTo"] ? T_5 extends unknown ? string : string | T_5 : never : never;
+    };
+    zIndexBase: Omit<{
+        type: NumberConstructor;
+        default: number;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["zIndexBase"] extends infer T_6 ? T_6 extends Defaults["zIndexBase"] ? T_6 extends unknown ? number : number | T_6 : never : never>;
+        default: Defaults["zIndexBase"] extends infer T_7 ? T_7 extends Defaults["zIndexBase"] ? T_7 extends unknown ? number : number | T_7 : never : never;
+    };
+    position: Omit<{
+        type: PropType<OverlayPosition>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["position"] extends infer T_8 ? T_8 extends Defaults["position"] ? T_8 extends unknown ? OverlayPosition : OverlayPosition | T_8 : never : never>;
+        default: Defaults["position"] extends infer T_9 ? T_9 extends Defaults["position"] ? T_9 extends unknown ? OverlayPosition : T_9 | NonNullable<OverlayPosition> : never : never;
+    };
+    placement: Omit<{
+        type: PropType<OverlayPlacement>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["placement"] extends infer T_10 ? T_10 extends Defaults["placement"] ? T_10 extends unknown ? OverlayPlacement : OverlayPlacement | T_10 : never : never>;
+        default: Defaults["placement"] extends infer T_11 ? T_11 extends Defaults["placement"] ? T_11 extends unknown ? OverlayPlacement : T_11 | NonNullable<OverlayPlacement> : never : never;
+    };
+    persistent: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["persistent"] extends infer T_12 ? T_12 extends Defaults["persistent"] ? T_12 extends unknown ? boolean : boolean | T_12 : never : never>;
+        default: Defaults["persistent"] extends infer T_13 ? T_13 extends Defaults["persistent"] ? T_13 extends unknown ? boolean : boolean | T_13 : never : never;
+    };
+    closeOnEsc: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["closeOnEsc"] extends infer T_14 ? T_14 extends Defaults["closeOnEsc"] ? T_14 extends unknown ? boolean : boolean | T_14 : never : never>;
+        default: Defaults["closeOnEsc"] extends infer T_15 ? T_15 extends Defaults["closeOnEsc"] ? T_15 extends unknown ? boolean : boolean | T_15 : never : never;
+    };
+    closeOnOutside: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["closeOnOutside"] extends infer T_16 ? T_16 extends Defaults["closeOnOutside"] ? T_16 extends unknown ? boolean : boolean | T_16 : never : never>;
+        default: Defaults["closeOnOutside"] extends infer T_17 ? T_17 extends Defaults["closeOnOutside"] ? T_17 extends unknown ? boolean : boolean | T_17 : never : never;
+    };
+    lockScroll: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["lockScroll"] extends infer T_18 ? T_18 extends Defaults["lockScroll"] ? T_18 extends unknown ? boolean : boolean | T_18 : never : never>;
+        default: Defaults["lockScroll"] extends infer T_19 ? T_19 extends Defaults["lockScroll"] ? T_19 extends unknown ? boolean : boolean | T_19 : never : never;
+    };
+    scrim: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["scrim"] extends infer T_20 ? T_20 extends Defaults["scrim"] ? T_20 extends unknown ? boolean : boolean | T_20 : never : never>;
+        default: Defaults["scrim"] extends infer T_21 ? T_21 extends Defaults["scrim"] ? T_21 extends unknown ? boolean : boolean | T_21 : never : never;
+    };
+    disabled: {
+        type: PropType<Defaults["disabled"] extends infer T_22 ? T_22 extends Defaults["disabled"] ? T_22 extends unknown ? boolean : boolean | T_22 : never : never>;
+        default: Defaults["disabled"] extends infer T_23 ? T_23 extends Defaults["disabled"] ? T_23 extends unknown ? boolean : boolean | T_23 : never : never;
+    };
+    transition: Omit<Omit<{
+        type: PropType<import("@/use/transition").GTransitionValue>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: PropType<import("@/use/transition").GTransitionValue>;
+        default: import("@/use/transition").GTransitionValue;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["transition"] extends infer T_24 ? T_24 extends Defaults["transition"] ? T_24 extends unknown ? import("@/use/transition").GTransitionValue : import("@/use/transition").GTransitionValue | T_24 : never : never>;
+        default: Defaults["transition"] extends infer T_25 ? T_25 extends Defaults["transition"] ? T_25 extends unknown ? import("@/use/transition").GTransitionValue : NonNullable<import("@/use/transition").GTransitionValue> | T_25 : never : never;
+    };
+};
+export type GOverlayProps = ExtractPropTypes<ReturnType<typeof makeOverlayProps>>;

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

@@ -0,0 +1,16 @@
+import { type PropType } from 'vue';
+import { type Placement } from '@/types/CommonTypes';
+export declare const makePlacementProps: <Defaults extends {
+    placement?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    placement: Omit<{
+        type: PropType<Placement>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["placement"] extends infer T ? T extends Defaults["placement"] ? T extends unknown ? Placement : Placement | T : never : never>;
+        default: Defaults["placement"] extends infer T_1 ? T_1 extends Defaults["placement"] ? T_1 extends unknown ? Placement : T_1 | NonNullable<Placement> : never : never;
+    };
+};
+export declare function usePlacement(props: {
+    placement: Placement;
+}, base: string): import("vue").ComputedRef<string>;

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

@@ -0,0 +1,4 @@
+import type { PXtype } from '@/types/CommonTypes';
+import { type ComputedRef, type MaybeRef } from 'vue';
+declare const _default: (value: MaybeRef<PXtype>) => ComputedRef<string>;
+export default _default;

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

@@ -0,0 +1,12 @@
+import { type PropType } from 'vue';
+export declare const makeRoundedProps: <Defaults extends {
+    rounded?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    rounded: {
+        type: PropType<Defaults["rounded"] extends infer T ? T extends Defaults["rounded"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["rounded"] extends infer T_1 ? T_1 extends Defaults["rounded"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+};
+export declare function useRounded(props: {
+    rounded?: boolean;
+}, base: string): import("vue").ComputedRef<string>;

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

@@ -0,0 +1,10 @@
+import { type Component } from 'vue';
+export type RouterTo = string | {
+    path?: string;
+    name?: string | symbol;
+    params?: Record<string, unknown>;
+    query?: Record<string, unknown>;
+    hash?: string;
+};
+export declare const useOptionalRouterLink: () => Component | string | undefined;
+export declare const getRouterFallbackHref: (to: RouterTo | undefined) => string | undefined;

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

@@ -0,0 +1,18 @@
+import { type MaybeRef } from 'vue';
+import type { GMenuItemBase } from '@/use/menu';
+import type { SelectBaseProps, SelectionValue } from './types';
+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 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>;
+    shouldCloseOnSelect: import("vue").ComputedRef<boolean>;
+    menuItems: import("vue").ComputedRef<import("./menuItems").SelectMenuItem<T, V>[]>;
+    resolveMenuItem: (item: GMenuItemBase) => import("./menuItems").SelectMenuItem<T, V> | undefined;
+    isMenuItemSelected: (item: GMenuItemBase) => boolean;
+    handleSelect: (item: GMenuItemBase, onClose?: () => void) => void;
+    selectedItems: import("vue").ComputedRef<import("./types").InternalItem<T, V>[]>;
+    hasSelection: import("vue").ComputedRef<boolean>;
+    selectionText: import("vue").ComputedRef<string>;
+};
+export {};

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

@@ -0,0 +1,14 @@
+import { type MaybeRef } from 'vue';
+import type { InternalItem, SelectItemChildren, SelectLabelKey, SelectValueKey } from './types';
+interface UseItemsOptions<T, V> {
+    items: MaybeRef<readonly T[]>;
+    labelKey?: MaybeRef<SelectLabelKey<T> | undefined>;
+    valueKey?: MaybeRef<SelectValueKey<T, V> | undefined>;
+    itemChildren?: MaybeRef<SelectItemChildren<T> | undefined>;
+}
+export declare function useItems<T, V = unknown>(options: UseItemsOptions<T, V>): {
+    items: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    resolveLabel: (item: T) => string;
+    resolveValue: (item: T) => V;
+};
+export {};

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

@@ -0,0 +1,11 @@
+import { type ComputedRef, type Ref } from 'vue';
+import type { GMenuItemBase } from '@/use/menu';
+import type { InternalItem } from './types';
+export interface SelectMenuItem<T, V> extends InternalItem<T, V> {
+    id: string;
+    children?: SelectMenuItem<T, V>[];
+}
+export declare function useSelectMenuItems<T, V>(items: Ref<InternalItem<T, V>[]>): {
+    menuItems: ComputedRef<SelectMenuItem<T, V>[]>;
+    resolveMenuItem: (item: GMenuItemBase) => SelectMenuItem<T, V> | undefined;
+};

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

@@ -0,0 +1,5 @@
+import type { GMenuItemBase } from '@/use/menu';
+import type { SelectMenuItem } from './menuItems';
+export declare function useSelectMenuSlot<T, V>(resolveMenuItem: (item: GMenuItemBase) => SelectMenuItem<T, V> | undefined): {
+    getSlotItem: (item: GMenuItemBase) => SelectMenuItem<T, V>;
+};

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

@@ -0,0 +1,12 @@
+import { type MaybeRef } from 'vue';
+import type { InternalItem, SelectionValue, SelectionValueComparator } from './types';
+export declare function useSelection<T, V, Multiple extends boolean, ReturnObject extends boolean>(props: {
+    modelValue: MaybeRef<SelectionValue<T, V, Multiple, ReturnObject>>;
+    multiple?: MaybeRef<unknown>;
+    returnObject?: MaybeRef<unknown>;
+    comparator?: SelectionValueComparator<SelectionValue<T, V, Multiple, ReturnObject>>;
+}, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    isSelected: (item: InternalItem<T, V>) => boolean;
+    getNextValue: (item: InternalItem<T, V>) => SelectionValue<T, V, Multiple, ReturnObject> | undefined;
+    select: (item: InternalItem<T, V>) => void;
+};

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

@@ -0,0 +1,19 @@
+import { type MaybeRef } from 'vue';
+import type { InternalItem, SelectionValue, SelectionValueComparator, SelectItemChildren, SelectLabelKey, SelectValueKey } from './types';
+type MaybeRefSelectionControllerProps<T, V, Multiple extends boolean, ReturnObject extends boolean> = {
+    items: MaybeRef<readonly T[]>;
+    modelValue: MaybeRef<SelectionValue<T, V, Multiple, ReturnObject>>;
+    labelKey?: MaybeRef<SelectLabelKey<T> | undefined>;
+    valueKey?: MaybeRef<SelectValueKey<T, V> | undefined>;
+    itemChildren?: MaybeRef<SelectItemChildren<T> | undefined>;
+    returnObject?: MaybeRef<ReturnObject | undefined>;
+    multiple?: MaybeRef<Multiple | undefined>;
+    valueComparator?: MaybeRef<SelectionValueComparator<SelectionValue<T, V, Multiple, ReturnObject>> | undefined>;
+};
+export declare function useSelectionController<T, V, Multiple extends boolean, ReturnObject extends boolean>(props: MaybeRefSelectionControllerProps<T, V, Multiple, ReturnObject>, emit: (e: 'update:modelValue', value: SelectionValue<T, V, Multiple, ReturnObject>) => void): {
+    items: import("vue").ComputedRef<InternalItem<T, V>[]>;
+    isItemSelected: (item: InternalItem<T, V>) => boolean;
+    getNextItemValue: (item: InternalItem<T, V>) => SelectionValue<T, V, Multiple, ReturnObject> | undefined;
+    selectItem: (item: InternalItem<T, V>) => void;
+};
+export {};