duoyun-ui 2.2.3 → 2.2.8

package/react/DyTextMask.d.ts

@@ -0,0 +1,20 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTextMaskElement } from '../elements/text-mask';
+export * from '../elements/text-mask';
+export type DyTextMaskProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTextMaskElement> & {
+    origin?: DuoyunTextMaskElement['origin'];
+    placeholder?: DuoyunTextMaskElement['placeholder'];
+    replacer?: DuoyunTextMaskElement['replacer'];
+    masks?: DuoyunTextMaskElement['masks'];
+};
+export type DyTextMaskExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-text-mask': DyTextMaskProps;
+        }
+    }
+}
+export declare const DyTextMask: ForwardRefExoticComponent<Omit<DyTextMaskProps, "ref"> & RefAttributes<DyTextMaskExpose>>;
+export default DyTextMask;

package/react/DyTextMask.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/text-mask';
+export const DyTextMask = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["origin", "placeholder", "replacer", "masks"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-text-mask", { ref: elementRef, ...props });
+});
+export default DyTextMask;

package/react/DyTimePanel.d.ts

@@ -0,0 +1,19 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTimePanelElement } from '../elements/time-panel';
+export * from '../elements/time-panel';
+export type DyTimePanelProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTimePanelElement> & {
+    headless?: DuoyunTimePanelElement['headless'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunTimePanelElement['change']>[0]>) => void;
+    value?: DuoyunTimePanelElement['value'];
+};
+export type DyTimePanelExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-time-panel': DyTimePanelProps;
+        }
+    }
+}
+export declare const DyTimePanel: ForwardRefExoticComponent<Omit<DyTimePanelProps, "ref"> & RefAttributes<DyTimePanelExpose>>;
+export default DyTimePanel;

package/react/DyTimePanel.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/time-panel';
+export const DyTimePanel = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["headless", "value"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-time-panel", { ref: elementRef, ...props });
+});
+export default DyTimePanel;

package/react/DyTimePicker.d.ts

@@ -0,0 +1,25 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTimePickerElement } from '../elements/time-picker';
+export * from '../elements/time-picker';
+export type DyTimePickerProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTimePickerElement> & {
+    placeholder?: DuoyunTimePickerElement['placeholder'];
+    clearable?: DuoyunTimePickerElement['clearable'];
+    disabled?: DuoyunTimePickerElement['disabled'];
+    active?: DuoyunTimePickerElement['active'];
+    value?: DuoyunTimePickerElement['value'];
+    'onchange'?: (event: CustomEvent<Parameters<DuoyunTimePickerElement['change']>[0]>) => void;
+    'onclear'?: (event: CustomEvent<Parameters<DuoyunTimePickerElement['clear']>[0]>) => void;
+};
+export type DyTimePickerExpose = {
+    showPicker: DuoyunTimePickerElement['showPicker'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-time-picker': DyTimePickerProps;
+        }
+    }
+}
+export declare const DyTimePicker: ForwardRefExoticComponent<Omit<DyTimePickerProps, "ref"> & RefAttributes<DyTimePickerExpose>>;
+export default DyTimePicker;

package/react/DyTimePicker.js

@@ -0,0 +1,22 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/time-picker';
+export const DyTimePicker = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            showPicker(...args) {
+                return elementRef.current.showPicker(...args);
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["placeholder", "clearable", "disabled", "active", "value"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-time-picker", { ref: elementRef, ...props });
+});
+export default DyTimePicker;

package/react/DyTimeline.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTimelineElement } from '../elements/timeline';
+export * from '../elements/timeline';
+export type DyTimelineProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTimelineElement> & {
+    events?: DuoyunTimelineElement['events'];
+};
+export type DyTimelineExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-timeline': DyTimelineProps;
+        }
+    }
+}
+export declare const DyTimeline: ForwardRefExoticComponent<Omit<DyTimelineProps, "ref"> & RefAttributes<DyTimelineExpose>>;
+export default DyTimeline;

package/react/DyTimeline.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/timeline';
+export const DyTimeline = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["events"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-timeline", { ref: elementRef, ...props });
+});
+export default DyTimeline;

package/react/DyTitle.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTitleElement } from '../elements/title';
+export * from '../elements/title';
+export type DyTitleProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTitleElement> & {};
+export type DyTitleExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-title': DyTitleProps;
+        }
+    }
+}
+export declare const DyTitle: ForwardRefExoticComponent<Omit<DyTitleProps, "ref"> & RefAttributes<DyTitleExpose>>;
+export default DyTitle;

package/react/DyTitle.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/title';
+export const DyTitle = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-title", { ref: elementRef, ...props });
+});
+export default DyTitle;

package/react/DyToast.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunToastElement } from '../elements/toast';
+export * from '../elements/toast';
+export type DyToastProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunToastElement> & {
+    items?: DuoyunToastElement['items'];
+};
+export type DyToastExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-toast': DyToastProps;
+        }
+    }
+}
+export declare const DyToast: ForwardRefExoticComponent<Omit<DyToastProps, "ref"> & RefAttributes<DyToastExpose>>;
+export default DyToast;

package/react/DyToast.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/toast';
+export const DyToast = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["items"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-toast", { ref: elementRef, ...props });
+});
+export default DyToast;

package/react/DyTooltip.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTooltipElement } from '../elements/tooltip';
+export * from '../elements/tooltip';
+export type DyTooltipProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTooltipElement> & {};
+export type DyTooltipExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-tooltip': DyTooltipProps;
+        }
+    }
+}
+export declare const DyTooltip: ForwardRefExoticComponent<Omit<DyTooltipProps, "ref"> & RefAttributes<DyTooltipExpose>>;
+export default DyTooltip;

package/react/DyTooltip.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/tooltip';
+export const DyTooltip = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-tooltip", { ref: elementRef, ...props });
+});
+export default DyTooltip;

package/react/DyTree.d.ts

@@ -0,0 +1,29 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunTreeElement } from '../elements/tree';
+export * from '../elements/tree';
+export type DyTreeProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunTreeElement> & {
+    /**@deprecated */
+    data?: DuoyunTreeElement['data'];
+    items?: DuoyunTreeElement['items'];
+    highlights?: DuoyunTreeElement['highlights'];
+    'onitemclick'?: (event: CustomEvent<Parameters<DuoyunTreeElement['itemclick']>[0]>) => void;
+    'onitemcontextmenu'?: (event: CustomEvent<Parameters<DuoyunTreeElement['itemcontextmenu']>[0]>) => void;
+    'onexpand'?: (event: CustomEvent<Parameters<DuoyunTreeElement['expand']>[0]>) => void;
+    'oncollapse'?: (event: CustomEvent<Parameters<DuoyunTreeElement['collapse']>[0]>) => void;
+};
+export type DyTreeExpose = {
+    isExpand: DuoyunTreeElement['isExpand'];
+    expandToItems: DuoyunTreeElement['expandToItems'];
+    collapseItems: DuoyunTreeElement['collapseItems'];
+    iterateCollapseItem: DuoyunTreeElement['iterateCollapseItem'];
+};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-tree': DyTreeProps;
+        }
+    }
+}
+export declare const DyTree: ForwardRefExoticComponent<Omit<DyTreeProps, "ref"> & RefAttributes<DyTreeExpose>>;
+export default DyTree;

package/react/DyTree.js

@@ -0,0 +1,31 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/tree';
+export const DyTree = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {
+            isExpand(...args) {
+                return elementRef.current.isExpand(...args);
+            },
+            expandToItems(...args) {
+                return elementRef.current.expandToItems(...args);
+            },
+            collapseItems(...args) {
+                return elementRef.current.collapseItems(...args);
+            },
+            iterateCollapseItem(...args) {
+                return elementRef.current.iterateCollapseItem(...args);
+            },
+        };
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["data", "items", "highlights"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-tree", { ref: elementRef, ...props });
+});
+export default DyTree;

package/react/DyUnsafe.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunUnsafeElement } from '../elements/unsafe';
+export * from '../elements/unsafe';
+export type DyUnsafeProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunUnsafeElement> & {};
+export type DyUnsafeExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-unsafe': DyUnsafeProps;
+        }
+    }
+}
+export declare const DyUnsafe: ForwardRefExoticComponent<Omit<DyUnsafeProps, "ref"> & RefAttributes<DyUnsafeExpose>>;
+export default DyUnsafe;

package/react/DyUnsafe.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/unsafe';
+export const DyUnsafe = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-unsafe", { ref: elementRef, ...props });
+});
+export default DyUnsafe;

package/react/DyUse.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunUseElement } from '../elements/use';
+export * from '../elements/use';
+export type DyUseProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunUseElement> & {};
+export type DyUseExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-use': DyUseProps;
+        }
+    }
+}
+export declare const DyUse: ForwardRefExoticComponent<Omit<DyUseProps, "ref"> & RefAttributes<DyUseExpose>>;
+export default DyUse;

package/react/DyUse.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/use';
+export const DyUse = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        [].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-use", { ref: elementRef, ...props });
+});
+export default DyUse;

package/react/DyVestaboard.d.ts

@@ -0,0 +1,21 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunVestaboardElement } from '../elements/vestaboard';
+export * from '../elements/vestaboard';
+export type DyVestaboardProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunVestaboardElement> & {
+    char?: DuoyunVestaboardElement['char'];
+    variant?: DuoyunVestaboardElement['variant'];
+    direction?: DuoyunVestaboardElement['direction'];
+    duration?: DuoyunVestaboardElement['duration'];
+    debug?: DuoyunVestaboardElement['debug'];
+};
+export type DyVestaboardExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-vestaboard': DyVestaboardProps;
+        }
+    }
+}
+export declare const DyVestaboard: ForwardRefExoticComponent<Omit<DyVestaboardProps, "ref"> & RefAttributes<DyVestaboardExpose>>;
+export default DyVestaboard;

package/react/DyVestaboard.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/vestaboard';
+export const DyVestaboard = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["char", "variant", "direction", "duration", "debug"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-vestaboard", { ref: elementRef, ...props });
+});
+export default DyVestaboard;

package/react/DyWait.d.ts

@@ -0,0 +1,17 @@
+import { HTMLAttributes, RefAttributes } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { DuoyunWaitElement } from '../elements/wait';
+export * from '../elements/wait';
+export type DyWaitProps = HTMLAttributes<HTMLDivElement> & RefAttributes<DuoyunWaitElement> & {
+    modal?: DuoyunWaitElement['modal'];
+};
+export type DyWaitExpose = {};
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'dy-wait': DyWaitProps;
+        }
+    }
+}
+export declare const DyWait: ForwardRefExoticComponent<Omit<DyWaitProps, "ref"> & RefAttributes<DyWaitExpose>>;
+export default DyWait;

package/react/DyWait.js

@@ -0,0 +1,18 @@
+import React from 'react';
+import { forwardRef, useImperativeHandle, useRef, useLayoutEffect } from 'react';
+export * from '../elements/wait';
+export const DyWait = forwardRef(function (props, ref) {
+    const elementRef = useRef(null);
+    useImperativeHandle(ref, () => {
+        return {};
+    }, []);
+    // React Bug?
+    useLayoutEffect(() => {
+        const element = elementRef.current;
+        ["modal"].map(name => {
+            element[name] = props[name];
+        });
+    }, []);
+    return React.createElement("dy-wait", { ref: elementRef, ...props });
+});
+export default DyWait;

package/svelte/action-text.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes } from "svelte/elements";
+import { DuoyunActionTextElement } from '../elements/action-text';
+export * from '../elements/action-text';
+interface DyActionTextProps extends HTMLAttributes<HTMLElement> {
+    tooltip?: DuoyunActionTextElement['tooltip'];
+    color?: DuoyunActionTextElement['color'];
+    active?: DuoyunActionTextElement['active'];
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-action-text': DyActionTextProps;
+    }
+}

package/svelte/action-text.js

@@ -0,0 +1,2 @@
+export * from '../elements/action-text';
+;

package/svelte/alert.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes } from "svelte/elements";
+import { DuoyunAlertElement } from '../elements/alert';
+export * from '../elements/alert';
+interface DyAlertProps extends HTMLAttributes<HTMLElement> {
+    header?: DuoyunAlertElement['header'];
+    status?: DuoyunAlertElement['status'];
+    action?: DuoyunAlertElement['action'];
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-alert': DyAlertProps;
+    }
+}

package/svelte/alert.js

@@ -0,0 +1,2 @@
+export * from '../elements/alert';
+;

package/svelte/area-chart.d.ts

@@ -0,0 +1,40 @@
+import type { HTMLAttributes } from "svelte/elements";
+import { DuoyunAreaChartElement } from '../elements/area-chart';
+export * from '../elements/area-chart';
+interface DyAreaChartProps extends HTMLAttributes<HTMLElement> {
+    fill?: DuoyunAreaChartElement['fill'];
+    stroke?: DuoyunAreaChartElement['stroke'];
+    stack?: DuoyunAreaChartElement['stack'];
+    symbol?: DuoyunAreaChartElement['symbol'];
+    symbolRender?: DuoyunAreaChartElement['symbolRender'];
+    /**@deprecated */
+    chartzoom?: DuoyunAreaChartElement['chartzoom'];
+    chartZoom?: DuoyunAreaChartElement['chartZoom'];
+    range?: DuoyunAreaChartElement['range'];
+    smooth?: DuoyunAreaChartElement['smooth'];
+    gradient?: DuoyunAreaChartElement['gradient'];
+    sequences?: DuoyunAreaChartElement['sequences'];
+    'on:zoom'?: (event: CustomEvent<Parameters<DuoyunAreaChartElement['zoom']>[0]>) => void;
+    aspectRatio?: DuoyunAreaChartElement['aspectRatio'];
+    filters?: DuoyunAreaChartElement['filters'];
+    colors?: DuoyunAreaChartElement['colors'];
+    xAxi?: DuoyunAreaChartElement['xAxi'];
+    yAxi?: DuoyunAreaChartElement['yAxi'];
+    pAxi?: DuoyunAreaChartElement['pAxi'];
+    yMin?: DuoyunAreaChartElement['yMin'];
+    yMax?: DuoyunAreaChartElement['yMax'];
+    xStep?: DuoyunAreaChartElement['xStep'];
+    yStep?: DuoyunAreaChartElement['yStep'];
+    pStep?: DuoyunAreaChartElement['pStep'];
+    tooltip?: DuoyunAreaChartElement['tooltip'];
+    markLines?: DuoyunAreaChartElement['markLines'];
+    'on:indexclick'?: (event: CustomEvent<Parameters<DuoyunAreaChartElement['indexclick']>[0]>) => void;
+    loading?: DuoyunAreaChartElement['loading'];
+    noData?: DuoyunAreaChartElement['noData'];
+    genGradientId?: DuoyunAreaChartElement['genGradientId'];
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-area-chart': DyAreaChartProps;
+    }
+}

package/svelte/area-chart.js

@@ -0,0 +1,2 @@
+export * from '../elements/area-chart';
+;

package/svelte/avatar.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes } from "svelte/elements";
+import { DuoyunAvatarGroupElement } from '../elements/avatar';
+export * from '../elements/avatar';
+interface DyAvatarGroupProps extends HTMLAttributes<HTMLElement> {
+    max?: DuoyunAvatarGroupElement['max'];
+    size?: DuoyunAvatarGroupElement['size'];
+    crossorigin?: DuoyunAvatarGroupElement['crossorigin'];
+    /**@deprecated */
+    data?: DuoyunAvatarGroupElement['data'];
+    items?: DuoyunAvatarGroupElement['items'];
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-avatar-group': DyAvatarGroupProps;
+    }
+}

package/svelte/avatar.js

@@ -0,0 +1,2 @@
+export * from '../elements/avatar';
+;

package/svelte/badge.d.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes } from "svelte/elements";
+export * from '../elements/badge';
+interface DyBadgeProps extends HTMLAttributes<HTMLElement> {
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-badge': DyBadgeProps;
+    }
+}

package/svelte/badge.js

@@ -0,0 +1,2 @@
+export * from '../elements/badge';
+;

package/svelte/banner.d.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes } from "svelte/elements";
+export * from '../elements/banner';
+interface DyBannerProps extends HTMLAttributes<HTMLElement> {
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-banner': DyBannerProps;
+    }
+}

package/svelte/banner.js

@@ -0,0 +1,2 @@
+export * from '../elements/banner';
+;

package/svelte/bar-chart.d.ts

@@ -0,0 +1,17 @@
+import type { HTMLAttributes } from "svelte/elements";
+import { DuoyunBarChartElement } from '../elements/bar-chart';
+export * from '../elements/bar-chart';
+interface DyBarChartProps extends HTMLAttributes<HTMLElement> {
+    series?: DuoyunBarChartElement['series'];
+    gutter?: DuoyunBarChartElement['gutter'];
+    stack?: DuoyunBarChartElement['stack'];
+    sequences?: DuoyunBarChartElement['sequences'];
+    xAxi?: DuoyunBarChartElement['xAxi'];
+    onMouseMove?: DuoyunBarChartElement['onMouseMove'];
+    onMouseOut?: DuoyunBarChartElement['onMouseOut'];
+}
+declare module "svelte/elements" {
+    interface SvelteHTMLElements {
+        'dy-bar-chart': DyBarChartProps;
+    }
+}

package/svelte/bar-chart.js

@@ -0,0 +1,2 @@
+export * from '../elements/bar-chart';
+;