@moubing/bing-ui 0.1.0 → 0.1.1

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

@@ -0,0 +1,156 @@
+export type BingTableKey = string | number;
+export type BingTableAlign = 'left' | 'center' | 'right';
+export type BingTableFixed = 'left' | 'right';
+export type BingTableSize = 'sm' | 'md' | 'lg';
+export type BingTableVirtualMode = boolean | 'auto';
+export type BingTableSelectionMode = 'multiple' | 'single';
+export type BingTableSortOrder = 'asc' | 'desc' | null;
+export type BingTableRow = Record<string, unknown>;
+export type BingTableRowKeyGetter = (row: BingTableRow, index: number, path: number[]) => BingTableKey;
+export type BingTableRowClass = string | ((row: BingTableRow, index: number) => string | undefined);
+export type BingTableRowDisabled = string | ((row: BingTableRow, index: number) => boolean);
+export interface BingTableColumn {
+    key: string;
+    title?: string;
+    dataKey?: string;
+    width?: number | string;
+    minWidth?: number;
+    maxWidth?: number;
+    fixed?: BingTableFixed;
+    hidden?: boolean;
+    align?: BingTableAlign;
+    headerAlign?: BingTableAlign;
+    sortable?: boolean;
+    resizable?: boolean;
+    description?: string;
+    ellipsis?: boolean;
+    class?: string;
+    headerClass?: string;
+    sorter?: (left: BingTableRow, right: BingTableRow) => number;
+}
+export interface BingTableColumnResizePayload {
+    key: string;
+    width: number;
+    widths: Record<string, number>;
+}
+export interface BingTableColumnReorderPayload {
+    key: string;
+    from: number;
+    to: number;
+    order: string[];
+}
+export interface BingTableColumnVisibilityPayload {
+    key: string;
+    hidden: boolean;
+    hiddenColumnKeys: string[];
+}
+export interface BingTableColumnFixedPayload {
+    key: string;
+    fixed: BingTableFixed | null;
+    columnFixed: Record<string, BingTableFixed | null>;
+}
+export interface BingTableSelectionPayload {
+    keys: BingTableKey[];
+    rows: BingTableRow[];
+}
+export interface BingTableExpandPayload {
+    key: BingTableKey;
+    row: BingTableRow;
+    expanded: boolean;
+    expandedRowKeys: BingTableKey[];
+}
+export interface BingTablePageChangePayload {
+    page: number;
+    pageSize: number;
+}
+export interface BingTableSortPayload {
+    key: string | null;
+    order: BingTableSortOrder;
+    column?: BingTableColumn;
+}
+export interface BingTableProps {
+    data?: BingTableRow[];
+    columns?: BingTableColumn[];
+    rowKey?: string | BingTableRowKeyGetter;
+    childrenKey?: string;
+    height?: number | string;
+    maxHeight?: number | string;
+    size?: BingTableSize;
+    bordered?: boolean;
+    striped?: boolean;
+    loading?: boolean;
+    emptyText?: string;
+    loadingText?: string;
+    selectable?: boolean;
+    selectionMode?: BingTableSelectionMode;
+    selectedRowKeys?: BingTableKey[];
+    defaultSelectedRowKeys?: BingTableKey[];
+    rowDisabled?: 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;
+    virtual?: BingTableVirtualMode;
+    virtualThreshold?: number;
+    virtualRowHeight?: number;
+    virtualOverscan?: number;
+    pagination?: boolean;
+    remotePagination?: boolean;
+    preservePageHeight?: boolean;
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: number[];
+    total?: number;
+    sortKey?: string | null;
+    defaultSortKey?: string | null;
+    sortOrder?: BingTableSortOrder;
+    defaultSortOrder?: BingTableSortOrder;
+    rowClass?: BingTableRowClass;
+    ariaLabel?: string;
+}
+export interface BingTableEmits {
+    'update:selectedRowKeys': [keys: BingTableKey[]];
+    'selection-change': [payload: BingTableSelectionPayload];
+    'update:expandedRowKeys': [keys: BingTableKey[]];
+    'expand-change': [payload: BingTableExpandPayload];
+    'update:columnWidths': [widths: Record<string, number>];
+    'column-resize': [payload: BingTableColumnResizePayload];
+    'update:columnOrder': [order: string[]];
+    'column-reorder': [payload: BingTableColumnReorderPayload];
+    'update:hiddenColumnKeys': [keys: string[]];
+    'column-visibility-change': [payload: BingTableColumnVisibilityPayload];
+    'update:columnFixed': [columnFixed: Record<string, BingTableFixed | null>];
+    'column-fixed-change': [payload: BingTableColumnFixedPayload];
+    'update:page': [page: number];
+    'update:pageSize': [pageSize: number];
+    'page-change': [payload: BingTablePageChangePayload];
+    'update:sortKey': [key: string | null];
+    'update:sortOrder': [order: BingTableSortOrder];
+    'sort-change': [payload: BingTableSortPayload];
+    'row-click': [row: BingTableRow, event: MouseEvent];
+    scroll: [event: Event];
+}
+export interface BingTableExpose {
+    clearSelection: () => void;
+    toggleRowSelection: (key: BingTableKey, selected?: boolean) => void;
+    toggleRowExpansion: (key: BingTableKey, expanded?: boolean) => void;
+    resetColumns: () => void;
+    scrollTo: (top: number) => void;
+}

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';