@gradient-ui/core 0.2.0

package/dist/types/index.d.ts

@@ -0,0 +1,21 @@
+import type { Plugin } from 'vue';
+import './style.scss';
+import { installIcons, type IconsOptions } from '@/use/icon';
+import { type GradientUIThemeOptions } from '@/theme';
+import type { ColorInput } from '@/types/Colors';
+import { type GradientUIDefaults } from '@/use/defaults';
+export * from '@/components';
+export * from '@/directives';
+export * from '@/services';
+export * from '@/theme';
+export * from '@/use';
+export { installIcons };
+export type { ColorInput };
+export interface GradientUIOptions {
+    icons?: boolean | Partial<IconsOptions>;
+    theme?: false | ColorInput | GradientUIThemeOptions;
+    defaults?: GradientUIDefaults;
+}
+export declare function createGradientUI(options?: GradientUIOptions): Plugin<GradientUIOptions | undefined>;
+export declare const GradientUI: Plugin<GradientUIOptions | undefined>;
+export default GradientUI;

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

@@ -0,0 +1,2 @@
+export * from './useLoading';
+export * from './useSnackbar';

package/dist/types/services/useLoading.d.ts

@@ -0,0 +1,8 @@
+import type { GLoadingProps } from '@/components/ui/GLoading/types';
+export declare function useLoading(): {
+    show: (options: Partial<GLoadingProps & {
+        target: string | HTMLElement;
+    }>) => void;
+    hide: () => Promise<void>;
+    visible: import("vue").Ref<boolean, boolean>;
+};

package/dist/types/services/useSnackbar.d.ts

@@ -0,0 +1,22 @@
+import type { GSnackbarAction, GSnackbarCloseReason, GSnackbarLocation, GSnackbarProps } from '@/components/ui/GSnackbar/types';
+export type GSnackbarTransition = 'fade' | 'scale' | 'slide-x' | 'slide-y';
+export interface SnackbarOptions extends Partial<Omit<GSnackbarProps, 'action' | 'transition'>> {
+    action?: GSnackbarAction | string;
+    location?: GSnackbarLocation;
+    transition?: GSnackbarTransition;
+}
+interface SnackbarItem extends SnackbarOptions {
+    id: number;
+    open: boolean;
+    action?: GSnackbarAction;
+    location: GSnackbarLocation;
+}
+export declare function useSnackbar(): {
+    show: (options: SnackbarOptions | string) => {
+        id: number;
+        close: (reason?: GSnackbarCloseReason) => void;
+    };
+    closeAll: () => void;
+    items: import("vue").ShallowRef<SnackbarItem[], SnackbarItem[]>;
+};
+export {};

package/dist/types/theme/changeTone.d.ts

@@ -0,0 +1 @@
+export declare function changeTone(hex: string, newTone: number): string;

package/dist/types/theme/colorPallete.d.ts

@@ -0,0 +1,2 @@
+declare let materialPallete: {};
+export { materialPallete };

package/dist/types/theme/colorSeeds.d.ts

@@ -0,0 +1,21 @@
+export declare const MaterialSeeds: {
+    red: string;
+    pink: string;
+    purple: string;
+    deepPurple: string;
+    indigo: string;
+    blue: string;
+    lightBlue: string;
+    cyan: string;
+    teal: string;
+    green: string;
+    lightGreen: string;
+    lime: string;
+    yellow: string;
+    amber: string;
+    orange: string;
+    deepOrange: string;
+    brown: string;
+    grey: string;
+    blueGrey: string;
+};

package/dist/types/theme/default.d.ts

@@ -0,0 +1,97 @@
+import type { ColorInput } from '@/types/Colors';
+import { type App, type Ref, type ShallowRef } from 'vue';
+export declare const DEFAULT_SEED = "#4e51ff";
+export interface SeedTheme {
+    seedColor: ColorInput;
+}
+export type ThemeMode = 'light' | 'dark';
+export interface GradientUIThemeOptions {
+    seed?: ColorInput;
+    mode?: ThemeMode;
+    autoApply?: boolean;
+}
+export interface GradientUITheme {
+    seed: Ref<ColorInput>;
+    mode: Ref<ThemeMode>;
+    result: ShallowRef<ReturnType<typeof createDefaultTheme> | null>;
+    apply: () => ReturnType<typeof createDefaultTheme> | null;
+    setSeed: (seed: ColorInput) => ReturnType<typeof createDefaultTheme> | null;
+    setMode: (mode: ThemeMode) => ReturnType<typeof createDefaultTheme> | null;
+    toggleMode: () => ReturnType<typeof createDefaultTheme> | null;
+}
+export declare function createDefaultLightTheme(seed?: ColorInput): {
+    tokens: {
+        theme: {
+            warning: string;
+            onWarning: string;
+            warningContainer: string;
+            onWarningContainer: string;
+            success: string;
+            onSuccess: string;
+            successContainer: string;
+            onSuccessContainer: string;
+        };
+        colors: Record<string, string>;
+        gradient: {
+            main: string;
+            error: string;
+            warning: string;
+            success: string;
+        };
+    };
+    themeCSS: HTMLStyleElement;
+    colorsCSS: HTMLStyleElement;
+    gradientCSS: HTMLStyleElement;
+};
+export declare function createDefaultDarkTheme(seed?: ColorInput): {
+    tokens: {
+        theme: {
+            warning: string;
+            onWarning: string;
+            warningContainer: string;
+            onWarningContainer: string;
+            success: string;
+            onSuccess: string;
+            successContainer: string;
+            onSuccessContainer: string;
+        };
+        colors: Record<string, string>;
+        gradient: {
+            main: string;
+            error: string;
+            warning: string;
+            success: string;
+        };
+    };
+    themeCSS: HTMLStyleElement;
+    colorsCSS: HTMLStyleElement;
+    gradientCSS: HTMLStyleElement;
+};
+export declare function createDefaultTheme(seed?: ColorInput, mode?: ThemeMode): {
+    tokens: {
+        theme: {
+            warning: string;
+            onWarning: string;
+            warningContainer: string;
+            onWarningContainer: string;
+            success: string;
+            onSuccess: string;
+            successContainer: string;
+            onSuccessContainer: string;
+        };
+        colors: Record<string, string>;
+        gradient: {
+            main: string;
+            error: string;
+            warning: string;
+            success: string;
+        };
+    };
+    themeCSS: HTMLStyleElement;
+    colorsCSS: HTMLStyleElement;
+    gradientCSS: HTMLStyleElement;
+};
+export declare function createTheme(options?: GradientUIThemeOptions): GradientUITheme;
+export declare function provideTheme(theme?: GradientUITheme): GradientUITheme;
+export declare function installTheme(app: App, theme: GradientUITheme): void;
+export declare function useTheme(): GradientUITheme | null;

package/dist/types/theme/generateColors.d.ts

@@ -0,0 +1 @@
+export declare function generateMaterialColors(seed: string): Record<string, string>;

package/dist/types/theme/generateGradient.d.ts

@@ -0,0 +1,9 @@
+export declare function generateGradient(seedColor: string): {
+    0: string;
+    25: string;
+    50: string;
+    75: string;
+    100: string;
+};
+export declare function generateGradientCSS(seedColor: string, deg: number): string;
+export declare function generateMaterialGradients(seed: string, deg?: number): Record<string, string>;

package/dist/types/theme/getComplementaryColor.d.ts

@@ -0,0 +1 @@
+export declare function getComplementaryColor(hex: string): string;

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

@@ -0,0 +1 @@
+export { DEFAULT_SEED, createTheme, createDefaultDarkTheme, createDefaultLightTheme, createDefaultTheme, installTheme, provideTheme, useTheme, type GradientUITheme, type GradientUIThemeOptions, type SeedTheme, type ThemeMode } from './default';

package/dist/types/types/Colors.d.ts

@@ -0,0 +1,2 @@
+export type ColorInput = string | number;
+export type ArgbColor = number;

package/dist/types/types/CommonTypes.d.ts

@@ -0,0 +1,26 @@
+import * as mdi from '@mdi/js';
+import type { ExcludeString } from './UtilityTypes';
+import type { CamelToKebab } from './UtilityTypes';
+export type MdiIcon = ExcludeString<CamelToKebab<keyof typeof mdi>, 'mdi-'>;
+export interface PLAProps {
+    label?: string;
+    appendIcon?: MdiIcon;
+    prependIcon?: MdiIcon;
+}
+export interface PLASlots {
+    default?: () => unknown;
+    prepend?: () => unknown;
+    append?: () => unknown;
+}
+export type PXtype = number | string;
+export type Sizes = 's' | 'm' | 'l' | 'xl';
+export type Placement = 'top' | 'bottom' | 'left' | 'right' | 'center';
+type OptionalFields = {
+    [key: string]: any;
+};
+export interface option extends OptionalFields {
+    label: string;
+    value: string | number | object;
+}
+export type StringeredNumber = number | `${number}`;
+export {};

package/dist/types/types/UtilityTypes.d.ts

@@ -0,0 +1,2 @@
+export type CamelToKebab<T extends string> = T extends `${infer First}${infer Rest}` ? `${First extends Uppercase<First> ? '-' : ''}${Lowercase<First>}${CamelToKebab<Rest>}` : T;
+export type ExcludeString<T, K extends string> = T extends `${K}${infer Rest}` ? Rest : never;

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

@@ -0,0 +1,101 @@
+import type { PropType } from 'vue';
+import { type MdiIcon } from './../types/CommonTypes';
+export declare const makePLAProps: <Defaults extends {
+    prepend?: unknown;
+    append?: unknown;
+    label?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    prepend: {
+        type: PropType<Defaults["prepend"] extends infer T ? T extends Defaults["prepend"] ? T extends unknown ? MdiIcon : MdiIcon | T : never : never>;
+        default: Defaults["prepend"] extends infer T_1 ? T_1 extends Defaults["prepend"] ? T_1 extends unknown ? MdiIcon : NonNullable<MdiIcon> | T_1 : never : never;
+    };
+    append: {
+        type: PropType<Defaults["append"] extends infer T_2 ? T_2 extends Defaults["append"] ? T_2 extends unknown ? MdiIcon : MdiIcon | T_2 : never : never>;
+        default: Defaults["append"] extends infer T_3 ? T_3 extends Defaults["append"] ? T_3 extends unknown ? MdiIcon : NonNullable<MdiIcon> | T_3 : never : never;
+    };
+    label: {
+        type: PropType<Defaults["label"] extends infer T_4 ? T_4 extends Defaults["label"] ? T_4 extends unknown ? string : string | T_4 : never : never>;
+        default: Defaults["label"] extends infer T_5 ? T_5 extends Defaults["label"] ? T_5 extends unknown ? string : string | T_5 : never : never;
+    };
+};
+export declare const makePLASlots: <D extends Partial<{
+    prepend: (_props: {
+        icon: string;
+    }) => string;
+    append: (_props: {
+        label: string;
+    }) => string;
+    label: (props: {
+        label: string;
+    }) => string;
+}> = object>(defaults?: D | undefined) => {
+    prepend: {
+        fn: "prepend" extends infer T ? T extends "prepend" ? T extends keyof D ? {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T] | D[T] : {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T] : never : never;
+    };
+    append: {
+        fn: "append" extends infer T_1 ? T_1 extends "append" ? T_1 extends keyof D ? {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_1] | D[T_1] : {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_1] : never : never;
+    };
+    label: {
+        fn: "label" extends infer T_2 ? T_2 extends "label" ? T_2 extends keyof D ? {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_2] | D[T_2] : {
+            prepend: (_props: {
+                icon: string;
+            }) => string;
+            append: (_props: {
+                label: string;
+            }) => string;
+            label: (props: {
+                label: string;
+            }) => string;
+        }[T_2] : never : never;
+    };
+};

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

@@ -0,0 +1,38 @@
+export declare const makeActionProps: <Defaults extends {
+    rounded?: unknown;
+    size?: unknown;
+    variant?: unknown;
+    removable?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    rounded: Omit<{
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").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;
+    };
+    size: Omit<Omit<{
+        type: import("vue").PropType<import("../types/CommonTypes").Sizes>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("../types/CommonTypes").Sizes>;
+        default: import("../types/CommonTypes").Sizes;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<Defaults["size"] extends infer T_2 ? T_2 extends Defaults["size"] ? T_2 extends unknown ? import("../types/CommonTypes").Sizes : import("../types/CommonTypes").Sizes | T_2 : never : never>;
+        default: Defaults["size"] extends infer T_3 ? T_3 extends Defaults["size"] ? T_3 extends unknown ? import("../types/CommonTypes").Sizes : NonNullable<import("../types/CommonTypes").Sizes> | T_3 : never : never;
+    };
+    variant: Omit<Omit<{
+        type: import("vue").PropType<import("./variant").GVariant>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./variant").GVariant>;
+        default: import("./variant").GVariant;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<Defaults["variant"] extends infer T_4 ? T_4 extends Defaults["variant"] ? T_4 extends unknown ? import("./variant").GVariant : import("./variant").GVariant | T_4 : never : never>;
+        default: Defaults["variant"] extends infer T_5 ? T_5 extends Defaults["variant"] ? T_5 extends unknown ? import("./variant").GVariant : NonNullable<import("./variant").GVariant> | T_5 : never : never;
+    };
+    removable: {
+        type: import("vue").PropType<Defaults["removable"] extends infer T_6 ? T_6 extends Defaults["removable"] ? T_6 extends unknown ? boolean : boolean | T_6 : never : never>;
+        default: Defaults["removable"] extends infer T_7 ? T_7 extends Defaults["removable"] ? T_7 extends unknown ? boolean : boolean | T_7 : never : never;
+    };
+};

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

@@ -0,0 +1,123 @@
+import type { Sizes } from '@/types/CommonTypes';
+import type { GGradienStates } from '@/components/ui/GGradient/types';
+import { type MaybeRefOrGetter, type PropType } from 'vue';
+import { type SurfaceProps } from './surface';
+import type { GColor } from './color';
+import { type GVariant } from './variant';
+export interface ActionSurfaceProps extends SurfaceProps {
+    size: Sizes;
+    active?: boolean;
+    activeColor?: GColor;
+    activeState?: GGradienStates;
+    activeVariant?: GVariant;
+}
+export interface ActionSurfaceStateOptions {
+    focused?: MaybeRefOrGetter<boolean | undefined>;
+    selected?: MaybeRefOrGetter<boolean | undefined>;
+    active?: MaybeRefOrGetter<boolean | undefined>;
+}
+export declare const makeActionSurfaceProps: <Defaults extends {
+    active?: unknown;
+    activeColor?: unknown;
+    activeState?: unknown;
+    activeVariant?: unknown;
+    size?: unknown;
+    state?: unknown;
+    rounded?: unknown;
+    disabled?: unknown;
+    color?: unknown;
+    variant?: unknown;
+} = object>(defaults?: Defaults | undefined) => {
+    active: {
+        type: PropType<Defaults["active"] extends infer T ? T extends Defaults["active"] ? T extends unknown ? boolean : boolean | T : never : never>;
+        default: Defaults["active"] extends infer T_1 ? T_1 extends Defaults["active"] ? T_1 extends unknown ? boolean : boolean | T_1 : never : never;
+    };
+    activeColor: {
+        type: PropType<Defaults["activeColor"] extends infer T_2 ? T_2 extends Defaults["activeColor"] ? T_2 extends unknown ? string : string | T_2 : never : never>;
+        default: Defaults["activeColor"] extends infer T_3 ? T_3 extends Defaults["activeColor"] ? T_3 extends unknown ? string : string | T_3 : never : never;
+    };
+    activeState: {
+        type: PropType<Defaults["activeState"] extends infer T_4 ? T_4 extends Defaults["activeState"] ? T_4 extends unknown ? GGradienStates : GGradienStates | T_4 : never : never>;
+        default: Defaults["activeState"] extends infer T_5 ? T_5 extends Defaults["activeState"] ? T_5 extends unknown ? GGradienStates : NonNullable<GGradienStates> | T_5 : never : never;
+    };
+    activeVariant: {
+        type: PropType<Defaults["activeVariant"] extends infer T_6 ? T_6 extends Defaults["activeVariant"] ? T_6 extends unknown ? GVariant : GVariant | T_6 : never : never>;
+        default: Defaults["activeVariant"] extends infer T_7 ? T_7 extends Defaults["activeVariant"] ? T_7 extends unknown ? GVariant : NonNullable<GVariant> | T_7 : never : never;
+    };
+    size: Omit<Omit<{
+        type: PropType<Sizes>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<Sizes>;
+        default: Sizes;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["size"] extends infer T_8 ? T_8 extends Defaults["size"] ? T_8 extends unknown ? Sizes : Sizes | T_8 : never : never>;
+        default: Defaults["size"] extends infer T_9 ? T_9 extends Defaults["size"] ? T_9 extends unknown ? Sizes : NonNullable<Sizes> | T_9 : never : never;
+    };
+    state: Omit<Omit<{
+        type: PropType<GGradienStates>;
+        default: GGradienStates;
+    }, "type" | "default"> & {
+        type: PropType<GGradienStates>;
+        default: GGradienStates;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["state"] extends infer T_10 ? T_10 extends Defaults["state"] ? T_10 extends unknown ? GGradienStates : GGradienStates | T_10 : never : never>;
+        default: Defaults["state"] extends infer T_11 ? T_11 extends Defaults["state"] ? T_11 extends unknown ? GGradienStates : NonNullable<GGradienStates> | T_11 : never : never;
+    };
+    rounded: Omit<Omit<{
+        type: PropType<boolean>;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<boolean>;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["rounded"] extends infer T_12 ? T_12 extends Defaults["rounded"] ? T_12 extends unknown ? boolean : boolean | T_12 : never : never>;
+        default: Defaults["rounded"] extends infer T_13 ? T_13 extends Defaults["rounded"] ? T_13 extends unknown ? boolean : boolean | T_13 : never : never;
+    };
+    disabled: Omit<Omit<{
+        type: PropType<boolean>;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<boolean>;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["disabled"] extends infer T_14 ? T_14 extends Defaults["disabled"] ? T_14 extends unknown ? boolean : boolean | T_14 : never : never>;
+        default: Defaults["disabled"] extends infer T_15 ? T_15 extends Defaults["disabled"] ? T_15 extends unknown ? boolean : boolean | T_15 : never : never;
+    };
+    color: Omit<Omit<Omit<{
+        type: PropType<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_16 ? T_16 extends Defaults["color"] ? T_16 extends unknown ? string : string | T_16 : never : never>;
+        default: Defaults["color"] extends infer T_17 ? T_17 extends Defaults["color"] ? T_17 extends unknown ? string : string | T_17 : never : never;
+    };
+    variant: Omit<Omit<Omit<{
+        type: PropType<GVariant>;
+        default: string;
+    }, "type" | "default"> & {
+        type: PropType<GVariant>;
+        default: GVariant;
+    }, "type" | "default"> & {
+        type: PropType<GVariant>;
+        default: GVariant;
+    }, "type" | "default"> & {
+        type: PropType<Defaults["variant"] extends infer T_18 ? T_18 extends Defaults["variant"] ? T_18 extends unknown ? GVariant : GVariant | T_18 : never : never>;
+        default: Defaults["variant"] extends infer T_19 ? T_19 extends Defaults["variant"] ? T_19 extends unknown ? GVariant : NonNullable<GVariant> | T_19 : never : never;
+    };
+};
+export declare function useActionSurface(props: ActionSurfaceProps, baseClass: string, options?: ActionSurfaceStateOptions): {
+    actionSurfaceClasses: import("vue").ComputedRef<string[]>;
+    resolvedColor: import("vue").ComputedRef<string | undefined>;
+    resolvedState: import("vue").ComputedRef<import("./gradient").GGradienStates | undefined>;
+    resolvedVariant: import("vue").ComputedRef<GVariant>;
+    surfaceStyles: import("vue").ComputedRef<import("vue").CSSProperties>;
+    surfaceOverlayClasses: import("vue").ComputedRef<string[]>;
+    surfaceUnderlayClasses: import("vue").ComputedRef<string[]>;
+    surfaceContentClasses: import("vue").ComputedRef<string[]>;
+};

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

@@ -0,0 +1,4 @@
+export declare function useAppendTarget(appendTo?: string | null): {
+    hasAppendTarget: import("vue").ComputedRef<boolean>;
+    appendTarget: import("vue").ComputedRef<string>;
+};

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

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export declare function useBodyScrollLock(open: Ref<boolean>, enabled: Ref<boolean>): void;

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

@@ -0,0 +1,2 @@
+import { type ComputedRef, type MaybeRef } from 'vue';
+export declare function useBooleanProp(value: MaybeRef<unknown>): ComputedRef<boolean>;

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

@@ -0,0 +1,27 @@
+import { type ComputedRef } from 'vue';
+export declare const defaultBreakpoints: {
+    readonly sm: 600;
+    readonly md: 900;
+    readonly lg: 1200;
+    readonly xl: 1536;
+};
+export type BreakpointName = keyof typeof defaultBreakpoints;
+export type BreakpointMap = Record<string, number>;
+export type BreakpointTarget<T extends BreakpointMap> = keyof T | number;
+export declare function useBreakpoints<T extends BreakpointMap = typeof defaultBreakpoints>(breakpoints?: T): {
+    breakpoints: T;
+    width: import("vue").Ref<number, number>;
+    height: import("vue").Ref<number, number>;
+    name: ComputedRef<keyof T>;
+    up: (target: BreakpointTarget<T>) => ComputedRef<boolean>;
+    down: (target: BreakpointTarget<T>) => ComputedRef<boolean>;
+    between: (min: BreakpointTarget<T>, max: BreakpointTarget<T>) => ComputedRef<boolean>;
+    smAndUp: ComputedRef<boolean>;
+    smAndDown: ComputedRef<boolean>;
+    mdAndUp: ComputedRef<boolean>;
+    mdAndDown: ComputedRef<boolean>;
+    lgAndUp: ComputedRef<boolean>;
+    lgAndDown: ComputedRef<boolean>;
+    xlAndUp: ComputedRef<boolean>;
+    xlAndDown: ComputedRef<boolean>;
+};

package/dist/types/use/check/booleanControl.d.ts

@@ -0,0 +1,61 @@
+import { type Ref } from 'vue';
+import type { CheckboxProps, SwitchProps } from './types';
+type BooleanControlProps = CheckboxProps | SwitchProps;
+export declare function useCheckBooleanControl(props: BooleanControlProps, modelValue: Ref<boolean>, emit: {
+    change: (value: boolean, event: Event) => void;
+    focus: (event: FocusEvent) => void;
+    blur: (event: FocusEvent) => void;
+}, options: {
+    idPrefix: string;
+    indicatorKind: 'checkbox' | 'switch';
+}): {
+    controlProps: import("vue").ComputedRef<{
+        id: string;
+        inputType: "checkbox";
+        message: string;
+        checked: boolean;
+        focused: boolean;
+        state: import("../../components/ui/GGradient/types").GGradienStates | undefined;
+        rules?: import("gib-validate").ValidationRule<boolean>[];
+        name?: string;
+        label?: string;
+        color?: import("../colorResolver").GColor;
+        disabled?: boolean;
+        size?: import("../../types/CommonTypes").Sizes;
+        indicatorView?: import("./types").CheckIndicatorView;
+        inline?: boolean;
+    } | {
+        id: string;
+        inputType: "checkbox";
+        message: string;
+        checked: boolean;
+        focused: boolean;
+        state: import("../../components/ui/GGradient/types").GGradienStates | undefined;
+        rules?: import("gib-validate").ValidationRule<boolean>[];
+        name?: string;
+        label?: string;
+        color?: import("../colorResolver").GColor;
+        disabled?: boolean;
+        size?: import("../../types/CommonTypes").Sizes;
+        indicatorView?: import("./types").CheckIndicatorView;
+        inline?: boolean;
+    }>;
+    indicatorProps: import("vue").ComputedRef<{
+        kind: "switch" | "checkbox";
+        checked: boolean;
+        disabled: boolean | undefined;
+        size: import("../../types/CommonTypes").Sizes | undefined;
+        color: string | undefined;
+        state: import("../../components/ui/GGradient/types").GGradienStates | undefined;
+        view: import("./types").CheckIndicatorView | undefined;
+    }>;
+    handleChange: (event: Event) => void;
+    handleGroupFocusIn: (event: FocusEvent) => void;
+    handleGroupFocusOut: (event: FocusEvent) => void;
+    handlePointerDown: () => void;
+    handlePointerEnd: () => void;
+    $v: import("gib-validate").ValidationResult<{
+        modelValue: import("gib-validate").Validatable;
+    }>;
+};
+export {};

package/dist/types/use/check/groupFocus.d.ts

@@ -0,0 +1,17 @@
+export interface CheckGroupFocusEmitters {
+    focus?: (event: FocusEvent) => void;
+    blur?: (event: FocusEvent) => void;
+}
+export interface UseCheckGroupFocusOptions {
+    onFocusWithin: () => void;
+    onBlurWithin: () => void;
+    emitters?: CheckGroupFocusEmitters;
+}
+export declare function useCheckGroupFocus(options: UseCheckGroupFocusOptions): {
+    isFocusedWithin: import("vue").Ref<boolean, boolean>;
+    handleGroupFocusIn: (event: FocusEvent) => void;
+    handleGroupFocusOut: (event: FocusEvent) => void;
+    handlePointerDown: () => void;
+    handlePointerEnd: () => void;
+};
+export declare const useCheckFocusWithin: typeof useCheckGroupFocus;

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

@@ -0,0 +1,6 @@
+export type { CheckFieldProps, CheckOption, CheckOptionItemSlotProps, CheckComparatorValue, CheckValueComparator, CheckIndicatorView, CheckSelectionProps, CheckboxProps, SwitchProps, SelectionGroupProps, CheckGroupSlots, CheckControlSlots, CheckOptionGroupSlots, CheckControlEmits, CheckGroupEmits, CheckGroupRootEmits, CheckControlRootEmits } from './types';
+export { useCheckGroupFocus, useCheckFocusWithin } from './groupFocus';
+export { useCheckOptionGroup } from './optionGroup';
+export { useCheckBooleanControl } from './booleanControl';
+export { includesSelection, toggleSelection } from './selection';
+export { makeCheckFieldProps, makeCheckGroupVisualProps, makeCheckControlBaseProps, makeCheckGroupBaseProps, makeCheckBooleanControlProps } from './types';