@gradient-ui/core 0.2.0

package/dist/types/components/ui/GQuickActions/GQuickActions.vue.d.ts

@@ -0,0 +1,46 @@
+import type { GFABLabelPlacement } from '../GFAB/types';
+import type { GQuickActionsDirection, GQuickActionsProps } from './types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        trigger?: (slotProps: {
+            isOpened: boolean;
+            toggle: () => void;
+        }) => unknown;
+        action?: (slotProps: {
+            option: NonNullable<GQuickActionsProps["options"]>[number];
+            index: number;
+            labelPlacement: GFABLabelPlacement;
+        }) => unknown;
+    }> & {
+        trigger?: (slotProps: {
+            isOpened: boolean;
+            toggle: () => void;
+        }) => unknown;
+        action?: (slotProps: {
+            option: NonNullable<GQuickActionsProps["options"]>[number];
+            index: number;
+            labelPlacement: GFABLabelPlacement;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<GQuickActionsProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<GQuickActionsProps> & Readonly<{}>, {
+    transition: import("../../../use/transition.js").GTransitionValue;
+    position: import("../GFAB/types").GFABPosition;
+    direction: GQuickActionsDirection;
+    offset: number | string;
+    options: import("./types").GQuickActionsOption[];
+    labelPlacement: GFABLabelPlacement;
+    location: import("../GFAB/types").GFABLocation;
+    contained: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/GQuickActions/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GQuickActions } from './GQuickActions.vue';
+export type { GQuickActionsOption, GQuickActionsProps } from './types';

package/dist/types/components/ui/GQuickActions/types.d.ts

@@ -0,0 +1,19 @@
+import type { MdiIcon, option } from '@/types/CommonTypes';
+import type { GFABLabelPlacement, GFABLocation, GFABPosition } from '../GFAB/types';
+import type { GTransitionValue } from '@/use/transition';
+export interface GQuickActionsOption extends option {
+    icon: MdiIcon;
+}
+export type GQuickActionsDirection = 'top' | 'right' | 'bottom' | 'left';
+export interface GQuickActionsProps {
+    options?: GQuickActionsOption[];
+    icon: MdiIcon;
+    activeIcon: MdiIcon;
+    contained?: boolean;
+    position?: GFABPosition;
+    location?: GFABLocation;
+    direction?: GQuickActionsDirection;
+    transition?: GTransitionValue;
+    offset?: number | string;
+    labelPlacement?: GFABLabelPlacement;
+}

package/dist/types/components/ui/GRadio/GRadio.vue.d.ts

@@ -0,0 +1,24 @@
+import { type CheckOptionGroupSlots } from '@/use/check';
+import type { GRadioProps } from './types';
+declare const _default: <T, V = T, ReturnObject extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((value: ReturnObject extends true ? T | null : V | null, event: Event) => any) | undefined;
+        readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: ReturnObject extends true ? T | null : V | null) => any) | undefined;
+        readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onUpdate:modelValue"> & Partial<{}> & GRadioProps<T, V, ReturnObject>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        $v: import("gib-validate").ValidationResult<{
+            modelValue: import("gib-validate").Validatable;
+        }>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<CheckOptionGroupSlots<T>> & CheckOptionGroupSlots<T>;
+    emit: ((evt: "change", value: ReturnObject extends true ? T | null : V | null, event: Event) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "update:modelValue", value: ReturnObject extends true ? T | null : V | null) => void) & ((evt: "focus", event: FocusEvent) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GRadio/GRadioItem.vue.d.ts

@@ -0,0 +1,32 @@
+import type { GGradienStates } from '../GGradient/types';
+import type { Sizes } from '@/types/CommonTypes';
+import type { GColor } from '@/use/color';
+import type { CheckControlSlots, CheckIndicatorView } from '@/use/check';
+declare const _default: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onChange?: ((value: T, event: Event) => any) | undefined;
+        readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+        readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange"> & Partial<{}> & {
+        name: string;
+        label: string;
+        value: T;
+        checked?: boolean;
+        color?: GColor;
+        disabled?: boolean;
+        size?: Sizes;
+        state?: GGradienStates;
+        indicatorView?: CheckIndicatorView;
+        inline?: boolean;
+    }> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<Pick<CheckControlSlots, "default">> & Pick<CheckControlSlots, "default">;
+    emit: ((evt: "change", value: T, event: Event) => void) & ((evt: "blur", event: FocusEvent) => void) & ((evt: "focus", event: FocusEvent) => void);
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GRadio/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from './GRadio.vue';
+export { default as GRadioItem } from './GRadioItem.vue';
+export type { GRadioProps } from './types';

package/dist/types/components/ui/GRadio/types.d.ts

@@ -0,0 +1,12 @@
+import type { CheckIndicatorView, CheckValueComparator, SelectionGroupProps } from '@/use/check';
+import type { SelectionValue, SelectLabelKey, SelectValueKey } from '@/use/select/types';
+export interface GRadioProps<T, V = T, ReturnObject extends boolean = false> extends SelectionGroupProps<SelectionValue<T, V, false, ReturnObject>> {
+    modelValue: SelectionValue<T, V, false, ReturnObject>;
+    options: readonly T[];
+    name?: string;
+    labelKey?: SelectLabelKey<T>;
+    valueKey?: SelectValueKey<T, V>;
+    returnObject?: ReturnObject;
+    indicatorView?: CheckIndicatorView;
+    valueComparator?: CheckValueComparator<SelectionValue<T, V, false, ReturnObject>>;
+}

package/dist/types/components/ui/GSelect/GSelect.vue.d.ts

@@ -0,0 +1,29 @@
+import type { SelectionValue } from '@/use/select/types';
+import type { GSelectProps, GSelectSlots } from './types';
+declare const _default: <T, V, Multiple extends boolean = false, ReturnObject extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+        readonly onClear?: (() => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: SelectionValue<T, V, Multiple, ReturnObject>) => any) | undefined;
+        readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, never>, "onFocus" | "onBlur" | "onUpdate:modelValue" | "onClear"> & Partial<{}> & GSelectProps<T, V, Multiple, ReturnObject>> & import("vue").PublicProps;
+    expose(exposed: import("vue").ShallowUnwrapRef<{
+        $v: import("gib-validate").ValidationResult<{
+            modelValue: import("gib-validate").Validatable;
+        }>;
+    }>): void;
+    attrs: any;
+    slots: Readonly<GSelectSlots<T, V>> & GSelectSlots<T, V>;
+    emit: {
+        (e: "update:modelValue", value: SelectionValue<T, V, Multiple, ReturnObject>): void;
+        (e: "focus", event: FocusEvent): void;
+        (e: "blur", event: FocusEvent): void;
+        (e: "clear"): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/components/ui/GSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './GSelect.vue';
+export type { GSelectProps, GSelectSlots } from './types';

package/dist/types/components/ui/GSelect/types.d.ts

@@ -0,0 +1,32 @@
+import type { PLASlots } from '@/types/CommonTypes';
+import type { MdiIcon } from '@/types/CommonTypes';
+import type { Sizes } from '@/types/CommonTypes';
+import type { ValidationRule } from 'gib-validate';
+import type { GColor } from '@/use/color';
+import type { GGradienStates } from '../GGradient/types';
+import type { InternalItem, SelectBaseProps, SelectionValue } from '@/use/select/types';
+import type { SelectMenuItem } from '@/use/select/menuItems';
+export type GSelectProps<T, V, Multiple extends boolean = false, ReturnObject extends boolean = false> = SelectBaseProps<T, V, Multiple, ReturnObject> & {
+    label?: string;
+    color?: GColor;
+    placeholder?: string;
+    prependIcon?: MdiIcon;
+    appendIcon?: MdiIcon;
+    disabled?: boolean;
+    clearable?: boolean;
+    size?: Sizes;
+    state?: GGradienStates;
+    message?: string;
+    rules?: ValidationRule<SelectionValue<T, V, Multiple, ReturnObject>>[];
+};
+export interface GSelectSlots<T, V> extends PLASlots {
+    message?: () => unknown;
+    selection?: (props: {
+        selection: string;
+        selectedItems: InternalItem<T, V>[];
+    }) => unknown;
+    item?: (props: {
+        item: SelectMenuItem<T, V>;
+        selected: boolean;
+    }) => unknown;
+}

package/dist/types/components/ui/GSelectItem.vue.d.ts

@@ -0,0 +1,47 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    checked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    item: {
+        type: ObjectConstructor;
+        default: () => void;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    checked: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    color: string;
+    checked: boolean;
+    item: Record<string, any>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/GSnackbar/GSnackbar.vue.d.ts

@@ -0,0 +1,326 @@
+import { type GSnackbarCloseReason } from './types';
+declare function close(reason?: GSnackbarCloseReason): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        default?: () => unknown;
+        title?: () => unknown;
+        prepend?: () => unknown;
+        action?: (props: {
+            close: () => void;
+        }) => unknown;
+    }> & {
+        default?: () => unknown;
+        title?: () => unknown;
+        prepend?: () => unknown;
+        action?: (props: {
+            close: () => void;
+        }) => unknown;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    modelValue: Omit<{
+        type: import("vue").PropType<boolean | undefined>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean | undefined>;
+        default: boolean | undefined;
+    };
+    defaultOpen: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    text: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    icon: {
+        type: import("vue").PropType<import("../../../types/CommonTypes").MdiIcon>;
+        default: import("../../../types/CommonTypes").MdiIcon;
+    };
+    color: Omit<{
+        type: import("vue").PropType<import("../../../use/colorResolver").GColor>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    state: {
+        type: import("vue").PropType<import("../GGradient/types").GGradienStates>;
+        default: import("../GGradient/types").GGradienStates;
+    };
+    variant: Omit<{
+        type: import("vue").PropType<import("./types").GSnackbarVariant>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./types").GSnackbarVariant>;
+        default: import("./types").GSnackbarVariant;
+    };
+    location: Omit<{
+        type: import("vue").PropType<import("./types").GSnackbarLocation>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./types").GSnackbarLocation>;
+        default: import("./types").GSnackbarLocation;
+    };
+    position: Omit<{
+        type: import("vue").PropType<import("./types").GSnackbarPosition>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./types").GSnackbarPosition>;
+        default: import("./types").GSnackbarPosition;
+    };
+    transition: Omit<{
+        type: import("vue").PropType<import("../../../use/transition").GTransitionValue>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("../../../use/transition").GTransitionValue>;
+        default: import("../../../use/transition").GTransitionValue;
+    };
+    timeout: Omit<{
+        type: NumberConstructor;
+        default: number;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    persistent: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    closeable: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    action: {
+        type: import("vue").PropType<import("./types").GSnackbarAction>;
+        default: import("./types").GSnackbarAction;
+    };
+    actionText: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    closeOnAction: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    multiline: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    offset: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<string | number>;
+        default: string | number;
+    };
+    maxWidth: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<string | number>;
+        default: string | number;
+    };
+    pauseOnHover: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}>, {
+    open: () => void;
+    close: typeof close;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    close: (reason: GSnackbarCloseReason) => any;
+    "update:modelValue": (value: boolean) => any;
+    action: (value: unknown) => any;
+    "after-close": (reason: GSnackbarCloseReason) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: Omit<{
+        type: import("vue").PropType<boolean | undefined>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean | undefined>;
+        default: boolean | undefined;
+    };
+    defaultOpen: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    title: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    text: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    icon: {
+        type: import("vue").PropType<import("../../../types/CommonTypes").MdiIcon>;
+        default: import("../../../types/CommonTypes").MdiIcon;
+    };
+    color: Omit<{
+        type: import("vue").PropType<import("../../../use/colorResolver").GColor>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    state: {
+        type: import("vue").PropType<import("../GGradient/types").GGradienStates>;
+        default: import("../GGradient/types").GGradienStates;
+    };
+    variant: Omit<{
+        type: import("vue").PropType<import("./types").GSnackbarVariant>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./types").GSnackbarVariant>;
+        default: import("./types").GSnackbarVariant;
+    };
+    location: Omit<{
+        type: import("vue").PropType<import("./types").GSnackbarLocation>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./types").GSnackbarLocation>;
+        default: import("./types").GSnackbarLocation;
+    };
+    position: Omit<{
+        type: import("vue").PropType<import("./types").GSnackbarPosition>;
+        default: string;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("./types").GSnackbarPosition>;
+        default: import("./types").GSnackbarPosition;
+    };
+    transition: Omit<{
+        type: import("vue").PropType<import("../../../use/transition").GTransitionValue>;
+        default: undefined;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<import("../../../use/transition").GTransitionValue>;
+        default: import("../../../use/transition").GTransitionValue;
+    };
+    timeout: Omit<{
+        type: NumberConstructor;
+        default: number;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<number>;
+        default: number;
+    };
+    persistent: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    closeable: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    action: {
+        type: import("vue").PropType<import("./types").GSnackbarAction>;
+        default: import("./types").GSnackbarAction;
+    };
+    actionText: {
+        type: import("vue").PropType<string>;
+        default: string;
+    };
+    closeOnAction: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    multiline: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+    offset: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<string | number>;
+        default: string | number;
+    };
+    maxWidth: Omit<{
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<string | number>;
+        default: string | number;
+    };
+    pauseOnHover: Omit<{
+        type: BooleanConstructor;
+        default: boolean;
+    }, "type" | "default"> & {
+        type: import("vue").PropType<boolean>;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onClose?: ((reason: GSnackbarCloseReason) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onAction?: ((value: unknown) => any) | undefined;
+    "onAfter-close"?: ((reason: GSnackbarCloseReason) => any) | undefined;
+}>, {
+    state: import("../GGradient/types").GGradienStates;
+    icon: import("../../../types/CommonTypes").MdiIcon;
+    text: string;
+    transition: import("../../../use/transition").GTransitionValue;
+    title: string;
+    color: string;
+    variant: import("./types").GSnackbarVariant;
+    position: import("./types").GSnackbarPosition;
+    maxWidth: string | number;
+    offset: string | number;
+    modelValue: boolean | undefined;
+    defaultOpen: boolean;
+    location: import("./types").GSnackbarLocation;
+    action: import("./types").GSnackbarAction;
+    timeout: number;
+    persistent: boolean;
+    closeable: boolean;
+    actionText: string;
+    closeOnAction: boolean;
+    multiline: boolean;
+    pauseOnHover: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/ui/GSnackbar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as GSnackbar } from './GSnackbar.vue';
+export * from './types';