@moubing/bing-ui 0.1.0 → 0.2.0

package/dist/components/BingTable/BingTable.vue.d.ts

@@ -0,0 +1,142 @@
+import { BingTableColumn, BingTableExpose, BingTableFixed, BingTableKey, BingTableProps, BingTableRow, BingTableSortOrder } from './BingTable.types';
+interface BingTableResolvedColumn extends BingTableColumn {
+    dataKey: string;
+}
+declare var __VLS_1: {
+    selectedRowKeys: BingTableKey[];
+    visibleColumns: BingTableResolvedColumn[];
+}, __VLS_72: `header-${string}`, __VLS_73: {
+    column: BingTableResolvedColumn;
+}, __VLS_81: `header-${string}`, __VLS_82: {
+    column: BingTableResolvedColumn;
+}, __VLS_113: `cell-${string}`, __VLS_114: {
+    row: BingTableRow;
+    column: BingTableResolvedColumn;
+    value: unknown;
+    rowIndex: number;
+    level: number;
+}, __VLS_116: {
+    row: BingTableRow;
+    column: BingTableResolvedColumn;
+    value: unknown;
+    rowIndex: number;
+    level: number;
+};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_72>]?: (props: typeof __VLS_73) => any;
+} & {
+    [K in NonNullable<typeof __VLS_81>]?: (props: typeof __VLS_82) => any;
+} & {
+    [K in NonNullable<typeof __VLS_113>]?: (props: typeof __VLS_114) => any;
+} & {
+    toolbar?: (props: typeof __VLS_1) => any;
+} & {
+    cell?: (props: typeof __VLS_116) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingTableProps, BingTableExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    scroll: (event: Event) => any;
+    "update:selectedRowKeys": (keys: BingTableKey[]) => any;
+    "selection-change": (payload: import('./BingTable.types').BingTableSelectionPayload) => any;
+    "update:expandedRowKeys": (keys: BingTableKey[]) => any;
+    "expand-change": (payload: import('./BingTable.types').BingTableExpandPayload) => any;
+    "update:columnWidths": (widths: Record<string, number>) => any;
+    "column-resize": (payload: import('./BingTable.types').BingTableColumnResizePayload) => any;
+    "update:columnOrder": (order: string[]) => any;
+    "column-reorder": (payload: import('./BingTable.types').BingTableColumnReorderPayload) => any;
+    "update:hiddenColumnKeys": (keys: string[]) => any;
+    "column-visibility-change": (payload: import('./BingTable.types').BingTableColumnVisibilityPayload) => any;
+    "update:columnFixed": (columnFixed: Record<string, BingTableFixed | null>) => any;
+    "column-fixed-change": (payload: import('./BingTable.types').BingTableColumnFixedPayload) => any;
+    "update:page": (page: number) => any;
+    "update:pageSize": (pageSize: number) => any;
+    "page-change": (payload: import('./BingTable.types').BingTablePageChangePayload) => any;
+    "update:sortKey": (key: string | null) => any;
+    "update:sortOrder": (order: BingTableSortOrder) => any;
+    "sort-change": (payload: import('./BingTable.types').BingTableSortPayload) => any;
+    "row-click": (row: BingTableRow, event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingTableProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+    "onUpdate:selectedRowKeys"?: ((keys: BingTableKey[]) => any) | undefined;
+    "onSelection-change"?: ((payload: import('./BingTable.types').BingTableSelectionPayload) => any) | undefined;
+    "onUpdate:expandedRowKeys"?: ((keys: BingTableKey[]) => any) | undefined;
+    "onExpand-change"?: ((payload: import('./BingTable.types').BingTableExpandPayload) => any) | undefined;
+    "onUpdate:columnWidths"?: ((widths: Record<string, number>) => any) | undefined;
+    "onColumn-resize"?: ((payload: import('./BingTable.types').BingTableColumnResizePayload) => any) | undefined;
+    "onUpdate:columnOrder"?: ((order: string[]) => any) | undefined;
+    "onColumn-reorder"?: ((payload: import('./BingTable.types').BingTableColumnReorderPayload) => any) | undefined;
+    "onUpdate:hiddenColumnKeys"?: ((keys: string[]) => any) | undefined;
+    "onColumn-visibility-change"?: ((payload: import('./BingTable.types').BingTableColumnVisibilityPayload) => any) | undefined;
+    "onUpdate:columnFixed"?: ((columnFixed: Record<string, BingTableFixed | null>) => any) | undefined;
+    "onColumn-fixed-change"?: ((payload: import('./BingTable.types').BingTableColumnFixedPayload) => any) | undefined;
+    "onUpdate:page"?: ((page: number) => any) | undefined;
+    "onUpdate:pageSize"?: ((pageSize: number) => any) | undefined;
+    "onPage-change"?: ((payload: import('./BingTable.types').BingTablePageChangePayload) => any) | undefined;
+    "onUpdate:sortKey"?: ((key: string | null) => any) | undefined;
+    "onUpdate:sortOrder"?: ((order: BingTableSortOrder) => any) | undefined;
+    "onSort-change"?: ((payload: import('./BingTable.types').BingTableSortPayload) => any) | undefined;
+    "onRow-click"?: ((row: BingTableRow, event: MouseEvent) => any) | undefined;
+}>, {
+    columns: BingTableColumn[];
+    height: number | string;
+    maxHeight: number | string;
+    data: BingTableRow[];
+    ariaLabel: string;
+    size: import('./BingTable.types').BingTableSize;
+    loading: boolean;
+    page: number;
+    emptyText: string;
+    virtual: import('./BingTable.types').BingTableVirtualMode;
+    virtualThreshold: number;
+    virtualOverscan: number;
+    rowKey: string | import('./BingTable.types').BingTableRowKeyGetter;
+    childrenKey: string;
+    bordered: boolean;
+    striped: boolean;
+    loadingText: string;
+    selectable: boolean;
+    selectionMode: import('./BingTable.types').BingTableSelectionMode;
+    selectedRowKeys: BingTableKey[];
+    defaultSelectedRowKeys: BingTableKey[];
+    rowDisabled: import('./BingTable.types').BingTableRowDisabled;
+    selectOnRowClick: boolean;
+    selectionFixed: boolean;
+    selectionColumnWidth: number;
+    expandedRowKeys: BingTableKey[];
+    defaultExpandedRowKeys: BingTableKey[];
+    defaultExpandAll: boolean;
+    treeColumnKey: string;
+    indentSize: number;
+    columnWidths: Record<string, number>;
+    defaultColumnWidths: Record<string, number>;
+    columnOrder: string[];
+    defaultColumnOrder: string[];
+    hiddenColumnKeys: string[];
+    defaultHiddenColumnKeys: string[];
+    columnFixed: Record<string, BingTableFixed | null>;
+    defaultColumnFixed: Record<string, BingTableFixed | null>;
+    resizableColumns: boolean;
+    reorderableColumns: boolean;
+    showColumnControls: boolean;
+    virtualRowHeight: number;
+    pagination: boolean;
+    remotePagination: boolean;
+    preservePageHeight: boolean;
+    defaultPage: number;
+    pageSize: number;
+    defaultPageSize: number;
+    pageSizeOptions: number[];
+    total: number;
+    sortKey: string | null;
+    defaultSortKey: string | null;
+    sortOrder: BingTableSortOrder;
+    defaultSortOrder: BingTableSortOrder;
+    rowClass: import('./BingTable.types').BingTableRowClass;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingTable/index.d.ts

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

package/dist/components/BingTabs/BingTabs.types.d.ts

@@ -0,0 +1,42 @@
+export type BingTabValue = string | number;
+export type BingTabsSize = 'sm' | 'md' | 'lg';
+export type BingTabsVariant = 'pill' | 'glass' | 'soft';
+export type BingTabsActivation = 'auto' | 'manual';
+export interface BingTabItem {
+    value: BingTabValue;
+    label: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    [key: string]: unknown;
+}
+export interface BingTabsProps {
+    modelValue?: BingTabValue;
+    items?: BingTabItem[];
+    size?: BingTabsSize;
+    variant?: BingTabsVariant;
+    activation?: BingTabsActivation;
+    disabled?: boolean;
+    block?: boolean;
+    loop?: boolean;
+    animated?: boolean;
+    respectReducedMotion?: boolean;
+    ariaLabel?: string;
+}
+export interface BingTabsChangePayload {
+    value: BingTabValue;
+    previousValue?: BingTabValue;
+    item: BingTabItem;
+    previousItem?: BingTabItem;
+    event: MouseEvent | KeyboardEvent;
+}
+export interface BingTabsFocusPayload {
+    value: BingTabValue;
+    item: BingTabItem;
+    event: FocusEvent;
+}
+export interface BingTabsEmits {
+    'update:modelValue': [value: BingTabValue];
+    change: [payload: BingTabsChangePayload];
+    focus: [payload: BingTabsFocusPayload];
+    blur: [payload: BingTabsFocusPayload];
+}

package/dist/components/BingTabs/BingTabs.vue.d.ts

@@ -0,0 +1,40 @@
+import { BingTabItem, BingTabValue, BingTabsChangePayload, BingTabsFocusPayload, BingTabsProps } from './BingTabs.types';
+declare var __VLS_1: {
+    item: BingTabItem;
+    active: boolean;
+    disabled: boolean;
+};
+type __VLS_Slots = {} & {
+    item?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingTabsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BingTabValue) => any;
+    change: (payload: BingTabsChangePayload) => any;
+    focus: (payload: BingTabsFocusPayload) => any;
+    blur: (payload: BingTabsFocusPayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingTabsProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BingTabValue) => any) | undefined;
+    onChange?: ((payload: BingTabsChangePayload) => any) | undefined;
+    onFocus?: ((payload: BingTabsFocusPayload) => any) | undefined;
+    onBlur?: ((payload: BingTabsFocusPayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    ariaLabel: string;
+    modelValue: BingTabValue;
+    items: BingTabItem[];
+    size: import('./BingTabs.types').BingTabsSize;
+    variant: import('./BingTabs.types').BingTabsVariant;
+    activation: import('./BingTabs.types').BingTabsActivation;
+    block: boolean;
+    loop: boolean;
+    animated: boolean;
+    respectReducedMotion: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingTabs/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingTabs } from './BingTabs.vue';
+export type { BingTabItem, BingTabValue, BingTabsActivation, BingTabsChangePayload, BingTabsEmits, BingTabsFocusPayload, BingTabsProps, BingTabsSize, BingTabsVariant, } from './BingTabs.types';

package/dist/components/BingTag/BingTag.types.d.ts

@@ -0,0 +1,15 @@
+export type BingTagSize = 'sm' | 'md' | 'lg';
+export type BingTagTone = 'primary' | 'secondary' | 'neutral' | 'success' | 'danger' | 'warning';
+export type BingTagVariant = 'glass' | 'soft';
+export interface BingTagProps {
+    label?: string;
+    size?: BingTagSize;
+    tone?: BingTagTone;
+    variant?: BingTagVariant;
+    closable?: boolean;
+    disabled?: boolean;
+    closeAriaLabel?: string;
+}
+export interface BingTagEmits {
+    close: [event: MouseEvent];
+}

package/dist/components/BingTag/BingTag.vue.d.ts

@@ -0,0 +1,26 @@
+import { BingTagProps } from './BingTag.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingTagProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingTagProps> & Readonly<{
+    onClose?: ((event: MouseEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    label: string;
+    size: import('./BingTag.types').BingTagSize;
+    variant: import('./BingTag.types').BingTagVariant;
+    tone: import('./BingTag.types').BingTagTone;
+    closable: boolean;
+    closeAriaLabel: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingTag/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingTag } from './BingTag.vue';
+export type { BingTagEmits, BingTagProps, BingTagSize, BingTagTone, BingTagVariant, } from './BingTag.types';

package/dist/components/BingTextarea/BingTextarea.types.d.ts

@@ -0,0 +1,40 @@
+export type BingTextareaSize = 'sm' | 'md' | 'lg';
+export type BingTextareaAutosize = boolean | {
+    minRows?: number;
+    maxRows?: number;
+};
+export interface BingTextareaProps {
+    id?: string;
+    modelValue?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    rows?: number;
+    autosize?: BingTextareaAutosize;
+    maxLength?: number;
+    showCount?: boolean;
+    size?: BingTextareaSize;
+    block?: boolean;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+    name?: string;
+    autocomplete?: string;
+    spellcheck?: boolean | 'true' | 'false';
+    resize?: 'none' | 'vertical' | 'horizontal' | 'both';
+    clearAriaLabel?: string;
+}
+export interface BingTextareaEmits {
+    'update:modelValue': [value: string];
+    input: [value: string, event: Event];
+    clear: [];
+    focus: [event: FocusEvent];
+    blur: [event: FocusEvent];
+    keydown: [event: KeyboardEvent];
+}
+export interface BingTextareaExpose {
+    textarea: HTMLTextAreaElement | null;
+    focus: () => void;
+    blur: () => void;
+    select: () => void;
+}

package/dist/components/BingTextarea/BingTextarea.vue.d.ts

@@ -0,0 +1,38 @@
+import { BingTextareaExpose, BingTextareaProps } from './BingTextarea.types';
+declare const __VLS_export: import('vue').DefineComponent<BingTextareaProps, BingTextareaExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    input: (value: string, event: Event) => any;
+    "update:modelValue": (value: string) => any;
+    focus: (event: FocusEvent) => any;
+    blur: (event: FocusEvent) => any;
+    keydown: (event: KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<BingTextareaProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    onInput?: ((value: string, event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onKeydown?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    resize: "none" | "vertical" | "horizontal" | "both";
+    ariaLabel: string;
+    modelValue: string;
+    size: import('./BingTextarea.types').BingTextareaSize;
+    block: boolean;
+    name: string;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    placeholder: string;
+    clearable: boolean;
+    clearAriaLabel: string;
+    autocomplete: string;
+    spellcheck: boolean | "true" | "false";
+    rows: number;
+    autosize: import('./BingTextarea.types').BingTextareaAutosize;
+    maxLength: number;
+    showCount: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BingTextarea/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingTextarea } from './BingTextarea.vue';
+export type { BingTextareaAutosize, BingTextareaEmits, BingTextareaExpose, BingTextareaProps, BingTextareaSize, } from './BingTextarea.types';

package/dist/components/BingToast/BingToast.service.d.ts

@@ -0,0 +1,44 @@
+import { BingToastItem, BingToastRenderPosition, BingToastService, BingToastType } from './BingToast.types';
+export declare const bingToastItems: import('vue').Ref<{
+    id: string;
+    type: BingToastType;
+    title?: string | undefined;
+    message: string;
+    duration: number;
+    closable: boolean;
+    position: BingToastRenderPosition;
+    createdAt: number;
+    order: number;
+    ariaLabel?: string | undefined;
+    closeAriaLabel: string;
+    glass?: boolean | undefined;
+    glassBlur?: string | number | undefined;
+    glassOpacity?: number | undefined;
+    glassSaturation?: number | undefined;
+}[], BingToastItem[] | {
+    id: string;
+    type: BingToastType;
+    title?: string | undefined;
+    message: string;
+    duration: number;
+    closable: boolean;
+    position: BingToastRenderPosition;
+    createdAt: number;
+    order: number;
+    ariaLabel?: string | undefined;
+    closeAriaLabel: string;
+    glass?: boolean | undefined;
+    glassBlur?: string | number | undefined;
+    glassOpacity?: number | undefined;
+    glassSaturation?: number | undefined;
+}[]>;
+export declare const activeBingToastViewportId: import('vue').Ref<string | undefined, string | undefined>;
+export declare function pauseBingToastTimer(id: string | number): void;
+export declare function resumeBingToastTimer(id: string | number): void;
+export declare function pauseAllBingToastTimers(): void;
+export declare function restartAllBingToastTimers(): void;
+export declare function createBingToastViewportId(): string;
+export declare function registerBingToastViewport(id: string): void;
+export declare function unregisterBingToastViewport(id: string): void;
+export declare const bingToast: BingToastService;
+export declare function useBingToast(): BingToastService;

package/dist/components/BingToast/BingToast.types.d.ts

@@ -0,0 +1,58 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export declare const BING_TOAST_POSITIONS: readonly ["top", "bottom", "left", "right", "top-left", "top-right", "bottom-left", "bottom-right"];
+export declare const BING_TOAST_POSITION_ALIASES: readonly ["top-center", "bottom-center"];
+export declare const BING_TOAST_POSITION_OPTIONS: readonly ["top", "bottom", "left", "right", "top-left", "top-right", "bottom-left", "bottom-right", "top-center", "bottom-center"];
+export type BingToastRenderPosition = (typeof BING_TOAST_POSITIONS)[number];
+export type BingToastPosition = (typeof BING_TOAST_POSITION_OPTIONS)[number];
+export type BingToastViewportPosition = BingToastPosition | 'all';
+export type BingToastType = 'default' | 'success' | 'error' | 'loading' | 'warning' | 'info';
+export type BingToastInput = string | BingToastOptions;
+export interface BingToastOptions extends BingGlassEffectProps {
+    id?: string | number;
+    title?: string;
+    message?: string;
+    type?: BingToastType;
+    duration?: number;
+    closable?: boolean;
+    position?: BingToastPosition;
+    ariaLabel?: string;
+    closeAriaLabel?: string;
+}
+export interface BingToastItem extends BingGlassEffectProps {
+    id: string;
+    type: BingToastType;
+    title?: string;
+    message: string;
+    duration: number;
+    closable: boolean;
+    position: BingToastRenderPosition;
+    createdAt: number;
+    order: number;
+    ariaLabel?: string;
+    closeAriaLabel: string;
+}
+export interface BingToastProps extends BingGlassEffectProps {
+    viewportPosition?: BingToastViewportPosition;
+    zIndex?: number;
+    offset?: string | number;
+    gap?: string | number;
+    width?: string | number;
+    max?: number;
+}
+export interface BingToastEmits {
+    close: [toast: BingToastItem];
+}
+export interface BingToastService {
+    show: (input: BingToastInput) => string;
+    success: (input: BingToastInput) => string;
+    error: (input: BingToastInput) => string;
+    fail: (input: BingToastInput) => string;
+    failed: (input: BingToastInput) => string;
+    loading: (input: BingToastInput) => string;
+    warning: (input: BingToastInput) => string;
+    info: (input: BingToastInput) => string;
+    close: (id: string | number) => void;
+    clear: (position?: BingToastPosition) => void;
+    getToasts: () => BingToastItem[];
+}
+export declare function normalizeBingToastPosition(position: BingToastPosition | undefined, fallback?: BingToastRenderPosition): "left" | "right" | "bottom" | "top" | "top-left" | "top-right" | "bottom-left" | "bottom-right";

package/dist/components/BingToast/BingToast.vue.d.ts

@@ -0,0 +1,19 @@
+import { BingToastItem, BingToastProps } from './BingToast.types';
+declare const __VLS_export: import('vue').DefineComponent<BingToastProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (toast: BingToastItem) => any;
+}, string, import('vue').PublicProps, Readonly<BingToastProps> & Readonly<{
+    onClose?: ((toast: BingToastItem) => any) | undefined;
+}>, {
+    gap: string | number;
+    width: string | number;
+    zIndex: number;
+    glass: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    max: number;
+    offset: string | number;
+    viewportPosition: import('./BingToast.types').BingToastViewportPosition;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/components/BingToast/index.d.ts

@@ -0,0 +1,4 @@
+export { default as BingToast } from './BingToast.vue';
+export { bingToast, useBingToast } from './BingToast.service';
+export { BING_TOAST_POSITION_ALIASES, BING_TOAST_POSITION_OPTIONS, BING_TOAST_POSITIONS, normalizeBingToastPosition, } from './BingToast.types';
+export type { BingToastEmits, BingToastInput, BingToastItem, BingToastOptions, BingToastPosition, BingToastProps, BingToastRenderPosition, BingToastService, BingToastType, BingToastViewportPosition, } from './BingToast.types';

package/dist/components/BingTooltip/BingTooltip.shared.d.ts

@@ -0,0 +1,32 @@
+import { Component, Ref } from 'vue';
+import { BingTooltipAlign, BingTooltipCloseReason, BingTooltipPlacement } from './BingTooltip.types';
+export interface BingTooltipSharedOwner {
+    id: string;
+    rootRef: Ref<HTMLElement | null>;
+    contentComponent: Component;
+    clearCloseTimer: () => void;
+    getAlign: () => BingTooltipAlign;
+    getAriaLabel: () => string | undefined;
+    getCloseOnEsc: () => boolean;
+    getCloseOnOutside: () => boolean;
+    getHasContent: () => boolean;
+    getHasHoverTrigger: () => boolean;
+    getInteractive: () => boolean;
+    getGlassStyle: () => Record<string, string>;
+    getMaxWidth: () => string;
+    getOffset: () => number;
+    getPlacement: () => BingTooltipPlacement;
+    getTooltipId: () => string;
+    getViewportPadding: () => number;
+    getZIndex: () => number;
+    hide: (reason?: BingTooltipCloseReason) => void;
+    scheduleClose: (reason: BingTooltipCloseReason) => void;
+}
+export declare const sharedTooltipActiveOwner: import('vue').ShallowRef<BingTooltipSharedOwner | undefined, BingTooltipSharedOwner | undefined>;
+export declare const sharedTooltipHostId: import('vue').ShallowRef<string | undefined, string | undefined>;
+export declare const sharedTooltipPanelElement: import('vue').ShallowRef<HTMLElement | null, HTMLElement | null>;
+export declare const sharedTooltipSuppressRootClickOwnerId: import('vue').ShallowRef<string | undefined, string | undefined>;
+export declare const sharedTooltipShouldRender: import('vue').ShallowRef<boolean, boolean>;
+export declare function createTooltipOwnerId(): string;
+export declare function registerTooltipOwner(owner: BingTooltipSharedOwner): void;
+export declare function unregisterTooltipOwner(owner: BingTooltipSharedOwner): void;

package/dist/components/BingTooltip/BingTooltip.types.d.ts

@@ -0,0 +1,36 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingTooltipTrigger = 'hover' | 'click' | 'manual';
+export type BingTooltipPlacement = 'top' | 'right' | 'bottom' | 'left';
+export type BingTooltipAlign = 'start' | 'center' | 'end';
+export type BingTooltipOpenReason = 'hover' | 'click' | 'focus' | 'manual';
+export type BingTooltipCloseReason = 'hover' | 'click' | 'focus' | 'outside' | 'escape' | 'manual' | 'disabled';
+export interface BingTooltipProps extends BingGlassEffectProps {
+    modelValue?: boolean;
+    content?: string;
+    trigger?: BingTooltipTrigger | BingTooltipTrigger[];
+    placement?: BingTooltipPlacement;
+    align?: BingTooltipAlign;
+    disabled?: boolean;
+    interactive?: boolean;
+    openDelay?: number;
+    closeDelay?: number;
+    offset?: number;
+    viewportPadding?: number;
+    maxWidth?: string | number;
+    zIndex?: number;
+    closeOnOutside?: boolean;
+    closeOnEsc?: boolean;
+    id?: string;
+    ariaLabel?: string;
+}
+export interface BingTooltipEmits {
+    'update:modelValue': [value: boolean];
+    open: [reason: BingTooltipOpenReason];
+    close: [reason: BingTooltipCloseReason];
+}
+export interface BingTooltipExpose {
+    show: (reason?: BingTooltipOpenReason) => void;
+    hide: (reason?: BingTooltipCloseReason) => void;
+    toggle: (reason?: BingTooltipOpenReason | BingTooltipCloseReason) => void;
+    updatePosition: () => void;
+}

package/dist/components/BingTooltip/BingTooltip.vue.d.ts

@@ -0,0 +1,51 @@
+import { BingTooltipAlign, BingTooltipCloseReason, BingTooltipExpose, BingTooltipOpenReason, BingTooltipPlacement, BingTooltipProps, BingTooltipTrigger } from './BingTooltip.types';
+declare function show(reason?: BingTooltipOpenReason): void;
+declare function hide(reason?: BingTooltipCloseReason): void;
+declare function toggle(reason?: BingTooltipOpenReason | BingTooltipCloseReason): void;
+declare var __VLS_1: {
+    open: boolean;
+    show: typeof show;
+    hide: typeof hide;
+    toggle: typeof toggle;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingTooltipProps, BingTooltipExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+    close: (reason: BingTooltipCloseReason) => any;
+    open: (reason: BingTooltipOpenReason) => any;
+}, string, import('vue').PublicProps, Readonly<BingTooltipProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    onClose?: ((reason: BingTooltipCloseReason) => any) | undefined;
+    onOpen?: ((reason: BingTooltipOpenReason) => any) | undefined;
+}>, {
+    trigger: BingTooltipTrigger | BingTooltipTrigger[];
+    disabled: boolean;
+    content: string;
+    maxWidth: string | number;
+    zIndex: number;
+    glass: boolean;
+    ariaLabel: string;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    interactive: boolean;
+    id: string;
+    offset: number;
+    placement: BingTooltipPlacement;
+    align: BingTooltipAlign;
+    openDelay: number;
+    closeDelay: number;
+    viewportPadding: number;
+    closeOnOutside: boolean;
+    closeOnEsc: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingTooltip/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingTooltip } from './BingTooltip.vue';
+export type { BingTooltipAlign, BingTooltipCloseReason, BingTooltipEmits, BingTooltipExpose, BingTooltipOpenReason, BingTooltipPlacement, BingTooltipProps, BingTooltipTrigger, } from './BingTooltip.types';