@aifuxi/semi-ui-vue 0.1.0-alpha.0

package/dist/grid/Col.vue.d.ts

@@ -0,0 +1,13 @@
+import { ColProps, GridSlots } from './types';
+type __VLS_Slots = GridSlots;
+declare const __VLS_base: import('vue').DefineComponent<ColProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<ColProps> & Readonly<{}>, {
+    prefixCls: 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/grid/Row.vue.d.ts

@@ -0,0 +1,14 @@
+import { GridGutter, GridSlots, RowProps } from './types';
+type __VLS_Slots = GridSlots;
+declare const __VLS_base: import('vue').DefineComponent<RowProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<RowProps> & Readonly<{}>, {
+    prefixCls: string;
+    gutter: GridGutter | readonly [GridGutter, GridGutter];
+}, {}, {}, {}, 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/grid/grid-context.d.ts

@@ -0,0 +1,6 @@
+import { ComputedRef, InjectionKey } from 'vue';
+import { GridGutters } from './types';
+export interface GridRowContext {
+    gutters: ComputedRef<GridGutters>;
+}
+export declare const gridRowContextKey: InjectionKey<GridRowContext>;

package/dist/grid/index.d.ts

@@ -0,0 +1,5 @@
+import { default as Col } from './Col.vue';
+import { default as Row } from './Row.vue';
+export { Col, Row };
+export { GRID_BREAKPOINTS, GRID_RESPONSIVE_MAP, GRID_RESPONSIVE_PRIORITY } from './types';
+export type { ColProps, ColSize, GridBreakpoint, GridGutter, GridGutters, GridResponsiveCol, GridResponsiveMap, GridRowAlign, GridRowJustify, GridRowType, GridSlots, RowProps, } from './types';

package/dist/grid/index.js

@@ -0,0 +1,2 @@
+import { a as e, i as t, n, r, t as i } from "../grid-Cn2uBhRd.js";
+export { n as Col, r as GRID_BREAKPOINTS, t as GRID_RESPONSIVE_MAP, e as GRID_RESPONSIVE_PRIORITY, i as Row };

package/dist/grid/media-query.d.ts

@@ -0,0 +1,2 @@
+export type GridMediaQueryHandler = (matches: boolean) => void;
+export declare function registerGridMediaQuery(media: string, handler: GridMediaQueryHandler): () => void;

package/dist/grid/types.d.ts

@@ -0,0 +1,44 @@
+export declare const GRID_BREAKPOINTS: readonly ["xs", "sm", "md", "lg", "xl", "xxl"];
+export declare const GRID_RESPONSIVE_PRIORITY: readonly ["xxl", "xl", "lg", "md", "sm", "xs"];
+export declare const GRID_RESPONSIVE_MAP: Readonly<{
+    xs: "(max-width: 575px)";
+    sm: "(min-width: 576px)";
+    md: "(min-width: 768px)";
+    lg: "(min-width: 992px)";
+    xl: "(min-width: 1200px)";
+    xxl: "(min-width: 1600px)";
+}>;
+export type GridBreakpoint = (typeof GRID_BREAKPOINTS)[number];
+export type GridResponsiveMap = typeof GRID_RESPONSIVE_MAP;
+export type GridGutter = number | Partial<Record<GridBreakpoint, number>>;
+export type GridGutters = readonly [horizontal: number, vertical: number];
+export type GridRowType = 'flex';
+export type GridRowAlign = 'top' | 'middle' | 'bottom';
+export type GridRowJustify = 'start' | 'end' | 'center' | 'space-around' | 'space-between';
+export interface RowProps {
+    type?: GridRowType;
+    align?: GridRowAlign;
+    justify?: GridRowJustify;
+    gutter?: GridGutter | readonly [GridGutter, GridGutter];
+    prefixCls?: string;
+}
+export interface ColSize {
+    span?: number;
+    order?: number;
+    offset?: number;
+    push?: number;
+    pull?: number;
+}
+export type GridResponsiveCol = number | ColSize;
+export interface ColProps extends ColSize {
+    prefixCls?: string;
+    xs?: GridResponsiveCol;
+    sm?: GridResponsiveCol;
+    md?: GridResponsiveCol;
+    lg?: GridResponsiveCol;
+    xl?: GridResponsiveCol;
+    xxl?: GridResponsiveCol;
+}
+export interface GridSlots {
+    default?: () => unknown;
+}

package/dist/grid-Cn2uBhRd.js

@@ -0,0 +1,161 @@
+import { computed as e, createElementBlock as t, defineComponent as n, inject as r, mergeProps as i, onBeforeUnmount as a, onMounted as o, openBlock as s, provide as c, renderSlot as l, shallowReactive as u, unref as d, useAttrs as f } from "vue";
+//#region src/grid/grid-context.ts
+var p = Symbol("semi-grid-row-context"), m = [
+	"xs",
+	"sm",
+	"md",
+	"lg",
+	"xl",
+	"xxl"
+], h = [
+	"xxl",
+	"xl",
+	"lg",
+	"md",
+	"sm",
+	"xs"
+], g = Object.freeze({
+	xs: "(max-width: 575px)",
+	sm: "(min-width: 576px)",
+	md: "(min-width: 768px)",
+	lg: "(min-width: 992px)",
+	xl: "(min-width: 1200px)",
+	xxl: "(min-width: 1600px)"
+}), _ = /* @__PURE__ */ n({
+	name: "Col",
+	inheritAttrs: !1,
+	__name: "Col",
+	props: {
+		prefixCls: { default: "semi" },
+		xs: {},
+		sm: {},
+		md: {},
+		lg: {},
+		xl: {},
+		xxl: {},
+		span: {},
+		order: {},
+		offset: {},
+		push: {},
+		pull: {}
+	},
+	setup(n) {
+		let a = n, o = f(), c = r(p, null);
+		if (!c) throw Error("please make sure <Col> inside <Row>");
+		function u(e) {
+			let t = a[e];
+			return typeof t == "number" ? { span: t } : t ?? {};
+		}
+		function h(e) {
+			return e !== void 0;
+		}
+		let g = e(() => {
+			let e = `${a.prefixCls}-col`, t = [
+				e,
+				h(a.span) ? `${e}-${a.span}` : void 0,
+				a.order ? `${e}-order-${a.order}` : void 0,
+				a.offset ? `${e}-offset-${a.offset}` : void 0,
+				a.push ? `${e}-push-${a.push}` : void 0,
+				a.pull ? `${e}-pull-${a.pull}` : void 0,
+				o.class
+			];
+			for (let n of m) {
+				let r = u(n);
+				h(r.span) && t.push(`${e}-${n}-${r.span}`), h(r.order) && t.push(`${e}-${n}-order-${r.order}`), h(r.offset) && t.push(`${e}-${n}-offset-${r.offset}`), h(r.push) && t.push(`${e}-${n}-push-${r.push}`), h(r.pull) && t.push(`${e}-${n}-pull-${r.pull}`);
+			}
+			return t;
+		}), _ = e(() => ({
+			...c.gutters.value[0] > 0 ? {
+				paddingLeft: `${c.gutters.value[0] / 2}px`,
+				paddingRight: `${c.gutters.value[0] / 2}px`
+			} : {},
+			...c.gutters.value[1] > 0 ? {
+				paddingTop: `${c.gutters.value[1] / 2}px`,
+				paddingBottom: `${c.gutters.value[1] / 2}px`
+			} : {}
+		})), v = e(() => Object.fromEntries(Object.entries(o).filter(([e]) => e !== "class" && e !== "style")));
+		return (e, n) => (s(), t("div", i(v.value, {
+			class: g.value,
+			style: [_.value, d(o).style],
+			"x-semi-prop": "children"
+		}), [l(e.$slots, "default")], 16));
+	}
+});
+//#endregion
+//#region src/grid/media-query.ts
+function v(e, t) {
+	if (typeof window > "u" || typeof window.matchMedia != "function") return () => void 0;
+	let n = window.matchMedia(e), r = (e) => {
+		t(e.matches);
+	};
+	return r(n), typeof n.addEventListener == "function" ? (n.addEventListener("change", r), () => n.removeEventListener("change", r)) : (n.addListener(r), () => n.removeListener(r));
+}
+//#endregion
+//#region src/grid/Row.vue
+var y = /* @__PURE__ */ n({
+	name: "Row",
+	inheritAttrs: !1,
+	__name: "Row",
+	props: {
+		type: {},
+		align: {},
+		justify: {},
+		gutter: { default: 0 },
+		prefixCls: { default: "semi" }
+	},
+	setup(n) {
+		let r = n, _ = f(), y = u({
+			xs: !0,
+			sm: !0,
+			md: !0,
+			lg: !0,
+			xl: !0,
+			xxl: !0
+		}), b = [];
+		function x(e) {
+			if (typeof e == "number") return e || 0;
+			if (!e) return 0;
+			for (let t of h) {
+				let n = e[t];
+				if (y[t] && n !== void 0) return n;
+			}
+			return 0;
+		}
+		let S = e(() => {
+			let e = Array.isArray(r.gutter) ? r.gutter.slice(0, 2) : [r.gutter, 0];
+			return [x(e[0]), x(e[1])];
+		});
+		c(p, { gutters: S });
+		let C = e(() => {
+			let e = `${r.prefixCls}-row`;
+			return [
+				r.type === "flex" ? `${e}-flex` : e,
+				r.type && r.justify ? `${e}-${r.type}-${r.justify}` : void 0,
+				r.type && r.align ? `${e}-${r.type}-${r.align}` : void 0,
+				_.class
+			];
+		}), w = e(() => ({
+			...S.value[0] > 0 ? {
+				marginLeft: `${S.value[0] / -2}px`,
+				marginRight: `${S.value[0] / -2}px`
+			} : {},
+			...S.value[1] > 0 ? {
+				marginTop: `${S.value[1] / -2}px`,
+				marginBottom: `${S.value[1] / -2}px`
+			} : {}
+		})), T = e(() => Object.fromEntries(Object.entries(_).filter(([e]) => e !== "class" && e !== "style")));
+		return o(() => {
+			for (let e of m) b.push(v(g[e], (t) => {
+				typeof r.gutter == "object" && (y[e] = t);
+			}));
+		}), a(() => {
+			for (let e of b) e();
+		}), (e, n) => (s(), t("div", i(T.value, {
+			class: C.value,
+			style: [w.value, d(_).style],
+			"x-semi-prop": "children"
+		}), [l(e.$slots, "default")], 16));
+	}
+});
+//#endregion
+export { h as a, g as i, _ as n, m as r, y as t };

package/dist/highlight/Highlight.vue.d.ts

@@ -0,0 +1,10 @@
+import { HighlightProps } from './types';
+declare const __VLS_export: import('vue').DefineComponent<HighlightProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<HighlightProps> & Readonly<{}>, {
+    component: string;
+    sourceString: string;
+    autoEscape: boolean;
+    caseSensitive: boolean;
+    searchWords: import('./types').HighlightSearchWords;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/highlight/HighlightNodeRenderer.d.ts

@@ -0,0 +1,49 @@
+import { CSSProperties, PropType, VNode } from 'vue';
+import { HighlightChunk } from './internal-types';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    chunks: {
+        type: PropType<HighlightChunk[]>;
+        required: true;
+    };
+    component: {
+        type: StringConstructor;
+        required: true;
+    };
+    highlightClassName: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    highlightStyle: {
+        type: PropType<CSSProperties | undefined>;
+        default: undefined;
+    };
+    sourceString: {
+        type: StringConstructor;
+        required: true;
+    };
+}>, () => VNode[], {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    chunks: {
+        type: PropType<HighlightChunk[]>;
+        required: true;
+    };
+    component: {
+        type: StringConstructor;
+        required: true;
+    };
+    highlightClassName: {
+        type: PropType<string | undefined>;
+        default: undefined;
+    };
+    highlightStyle: {
+        type: PropType<CSSProperties | undefined>;
+        default: undefined;
+    };
+    sourceString: {
+        type: StringConstructor;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    highlightClassName: string | undefined;
+    highlightStyle: CSSProperties | undefined;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/highlight/index.d.ts

@@ -0,0 +1,4 @@
+import { default as Highlight } from './Highlight.vue';
+export { Highlight };
+export type { HighlightProps, HighlightSearchWord, HighlightSearchWords, HighlightSearchWordValue, } from './types';
+export default Highlight;

package/dist/highlight/index.js

@@ -0,0 +1,2 @@
+import { n as e, t } from "../highlight-DHX3RV0C.js";
+export { e as Highlight, t as default };

package/dist/highlight/internal-types.d.ts

@@ -0,0 +1,8 @@
+import { CSSProperties } from 'vue';
+export interface HighlightChunk {
+    start: number;
+    end: number;
+    highlight: boolean;
+    className?: string;
+    style?: CSSProperties;
+}

package/dist/highlight/types.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'vue';
+export interface HighlightSearchWord {
+    text: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export type HighlightSearchWordValue = string | HighlightSearchWord | undefined;
+export type HighlightSearchWords = HighlightSearchWordValue[];
+export interface HighlightProps {
+    autoEscape?: boolean;
+    caseSensitive?: boolean;
+    sourceString?: string;
+    searchWords?: HighlightSearchWords;
+    highlightStyle?: CSSProperties;
+    highlightClassName?: string;
+    component?: string;
+}

package/dist/highlight-DHX3RV0C.js

@@ -0,0 +1,158 @@
+import "./src-DNBBthjO.js";
+import { _ as e, t } from "./foundation-Cawx37mp.js";
+import { computed as n, createBlock as r, createTextVNode as i, defineComponent as a, h as o, markRaw as s, openBlock as c, unref as l } from "vue";
+//#region bundled-foundation
+var u = (e) => e.replace(/[\-\[\]\/\{\}\(\)\*\+\?\.\\\^\$\|]/g, "\\$&"), d = class extends t {
+	constructor(t) {
+		super({ ...t }), this.findAll = ({ autoEscape: t = !0, caseSensitive: n = !1, searchWords: r, sourceString: i }) => {
+			(0, e.default)(r) && (r = [r]);
+			let a = this.findChunks({
+				autoEscape: t,
+				caseSensitive: n,
+				searchWords: r,
+				sourceString: i
+			}), o = this.combineChunks({ chunks: a });
+			return this.fillInChunks({
+				chunksToHighlight: o,
+				totalLength: i ? i.length : 0
+			});
+		}, this.findChunks = ({ autoEscape: e, caseSensitive: t, searchWords: n, sourceString: r }) => n.map((e) => typeof e == "string" ? { text: e } : e).filter((e) => e.text).reduce((n, i) => {
+			let a = i.text;
+			e && (a = u(a));
+			let o = new RegExp(a, t ? "g" : "gi"), s;
+			for (; s = o.exec(r);) {
+				let e = s.index, t = o.lastIndex;
+				t > e && n.push({
+					highlight: !0,
+					start: e,
+					end: t,
+					className: i.className,
+					style: i.style
+				}), s.index === o.lastIndex && o.lastIndex++;
+			}
+			return n;
+		}, []), this.combineChunks = ({ chunks: e }) => e.sort((e, t) => e.start - t.start).reduce((e, t) => {
+			if (e.length === 0) return [t];
+			{
+				let n = e.pop();
+				if (t.start <= n.end) {
+					let r = Math.max(n.end, t.end);
+					e.push({
+						highlight: !0,
+						start: n.start,
+						end: r,
+						className: n.className || t.className,
+						style: {
+							...n.style,
+							...t.style
+						}
+					});
+				} else e.push(n, t);
+				return e;
+			}
+		}, []), this.fillInChunks = ({ chunksToHighlight: e, totalLength: t }) => {
+			let n = [], r = (e, t, r, i, a) => {
+				t - e > 0 && n.push({
+					start: e,
+					end: t,
+					highlight: r,
+					className: i,
+					style: a
+				});
+			};
+			if (e.length === 0) r(0, t, !1);
+			else {
+				let n = 0;
+				e.forEach((e) => {
+					r(n, e.start, !1), r(e.start, e.end, !0, e.className, e.style), n = e.end;
+				}), r(n, t, !1);
+			}
+			return n;
+		};
+	}
+}, f = a({
+	name: "HighlightNodeRenderer",
+	inheritAttrs: !1,
+	props: {
+		chunks: {
+			type: Array,
+			required: !0
+		},
+		component: {
+			type: String,
+			required: !0
+		},
+		highlightClassName: {
+			type: String,
+			default: void 0
+		},
+		highlightStyle: {
+			type: Object,
+			default: void 0
+		},
+		sourceString: {
+			type: String,
+			required: !0
+		}
+	},
+	setup(e) {
+		return () => e.chunks.map((t, n) => {
+			let r = e.sourceString.slice(t.start, t.end);
+			if (!t.highlight) return i(r);
+			let a = [
+				"semi-highlight-tag",
+				e.highlightClassName,
+				t.className
+			].filter(Boolean).join(" "), s = {
+				...e.highlightStyle,
+				...t.style
+			}, c = {
+				class: a,
+				key: `${r}${n}`
+			};
+			return Object.keys(s).length && (c.style = s), o(e.component, c, r);
+		});
+	}
+}), p = /* @__PURE__ */ a({
+	name: "Highlight",
+	inheritAttrs: !1,
+	__name: "Highlight",
+	props: {
+		autoEscape: {
+			type: Boolean,
+			default: !0
+		},
+		caseSensitive: {
+			type: Boolean,
+			default: !1
+		},
+		sourceString: { default: "" },
+		searchWords: { default: () => [] },
+		highlightStyle: {},
+		highlightClassName: {},
+		component: { default: "mark" }
+	},
+	setup(e) {
+		let t = e, i = s(new d()), a = n(() => i.findAll({
+			autoEscape: t.autoEscape,
+			caseSensitive: t.caseSensitive,
+			searchWords: t.searchWords,
+			sourceString: t.sourceString
+		}));
+		return (e, n) => (c(), r(l(f), {
+			chunks: a.value,
+			component: t.component,
+			"highlight-class-name": t.highlightClassName,
+			"highlight-style": t.highlightStyle,
+			"source-string": t.sourceString
+		}, null, 8, [
+			"chunks",
+			"component",
+			"highlight-class-name",
+			"highlight-style",
+			"source-string"
+		]));
+	}
+}), m = p;
+//#endregion
+export { p as n, m as t };

package/dist/icon/index.d.ts

@@ -0,0 +1,2 @@
+export { default, default as Icon } from '@aifuxi/semi-icons-vue';
+export type { IconExposed, IconFill, IconProps, IconSize, IconSlots } from '@aifuxi/semi-icons-vue';

package/dist/icon/index.js

@@ -0,0 +1,2 @@
+import e, { default as t } from "@aifuxi/semi-icons-vue";
+export { e as Icon, t as default };

package/dist/image/Image.vue.d.ts

@@ -0,0 +1,21 @@
+import { ImageProps, ImageSlots } from './types';
+type __VLS_Slots = ImageSlots;
+declare const __VLS_base: import('vue').DefineComponent<ImageProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    click: (event: MouseEvent) => any;
+    error: (event: Event) => any;
+    load: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<ImageProps> & Readonly<{
+    onClick?: (event: MouseEvent) => any;
+    onError?: (event: Event) => any;
+    onLoad?: (event: Event) => any;
+}>, {
+    preview: boolean | import('./types').ImagePreviewOptions | undefined;
+}, {}, {}, {}, 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/image/ImageNodeRenderer.d.ts

@@ -0,0 +1,15 @@
+import { PropType, VNodeChild } from 'vue';
+declare const _default: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    content: {
+        type: PropType<VNodeChild>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    content: VNodeChild;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/image/ImagePreview.vue.d.ts

@@ -0,0 +1,56 @@
+import { ImagePreviewProps, ImagePreviewSlots } from './types';
+type __VLS_Slots = ImagePreviewSlots;
+declare const __VLS_base: import('vue').DefineComponent<ImagePreviewProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (index: number) => any;
+    close: () => any;
+    next: (index: number) => any;
+    visibleChange: (visible: boolean) => any;
+    "update:visible": (visible: boolean) => any;
+    prev: (index: number) => any;
+    download: (src: string, index: number) => any;
+    downloadError: (src: string) => any;
+    ratioChange: (type: import('./types').ImageRatioType) => any;
+    rotateLeft: (angle: number) => any;
+    "update:currentIndex": (index: number) => any;
+    zoomIn: (zoom: number) => any;
+    zoomOut: (zoom: number) => any;
+}, string, import('vue').PublicProps, Readonly<ImagePreviewProps> & Readonly<{
+    onChange?: (index: number) => any;
+    onClose?: () => any;
+    onNext?: (index: number) => any;
+    onVisibleChange?: (visible: boolean) => any;
+    "onUpdate:visible"?: (visible: boolean) => any;
+    onPrev?: (index: number) => any;
+    onDownload?: (src: string, index: number) => any;
+    onDownloadError?: (src: string) => any;
+    onRatioChange?: (type: import('./types').ImageRatioType) => any;
+    onRotateLeft?: (angle: number) => any;
+    "onUpdate:currentIndex"?: (index: number) => any;
+    onZoomIn?: (zoom: number) => any;
+    onZoomOut?: (zoom: number) => any;
+}>, {
+    infinite: boolean | undefined;
+    zIndex: number | undefined;
+    closeOnEsc: boolean | undefined;
+    src: string | string[] | undefined;
+    disableDownload: boolean | undefined;
+    showTooltip: boolean | undefined;
+    closable: boolean | undefined;
+    maxZoom: number | undefined;
+    minZoom: number | undefined;
+    lazyLoad: boolean | undefined;
+    lazyLoadMargin: string | undefined;
+    maskClosable: boolean | undefined;
+    preLoad: boolean | undefined;
+    preLoadGap: number | undefined;
+    viewerVisibleDelay: number | undefined;
+    zoomStep: number | undefined;
+}, {}, {}, {}, 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/image/ImagePreviewFooter.vue.d.ts

@@ -0,0 +1,38 @@
+import { VNodeChild } from 'vue';
+import { ImageLocale, ImagePreviewMenuProps, ImageRatioType } from './types';
+interface FooterProps {
+    adaptiveTip?: string | undefined;
+    className?: string | undefined;
+    curPage: number;
+    disableDownload: boolean;
+    disabledNext: boolean;
+    disabledPrev: boolean;
+    downloadTip?: string | undefined;
+    locale: ImageLocale;
+    max: number;
+    min: number;
+    nextTip?: string | undefined;
+    onAdjustRatio: (type: ImageRatioType) => void;
+    onDownload: () => void;
+    onNext: () => void;
+    onPrev: () => void;
+    onRotate: (direction: string) => void;
+    onZoom: (zoom: number) => void;
+    originTip?: string | undefined;
+    prevTip?: string | undefined;
+    ratio: ImageRatioType;
+    renderPreviewMenu?: ((props: ImagePreviewMenuProps) => VNodeChild) | undefined;
+    rotateTip?: string | undefined;
+    showTooltip: boolean;
+    step: number;
+    totalNum: number;
+    zIndex: number;
+    zoom: number;
+    zoomInTip?: string | undefined;
+    zoomOutTip?: string | undefined;
+}
+declare const __VLS_export: import('vue').DefineComponent<FooterProps, {
+    element: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<FooterProps> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/image/ImagePreviewHeader.vue.d.ts

@@ -0,0 +1,17 @@
+import { VNodeChild } from 'vue';
+type __VLS_Props = {
+    className?: string | undefined;
+    closable: boolean;
+    renderCloseIcon?: VNodeChild | (() => VNodeChild) | undefined;
+    renderHeader?: ((title: VNodeChild) => VNodeChild) | undefined;
+    title?: VNodeChild | undefined;
+};
+declare const __VLS_export: import('vue').DefineComponent<__VLS_Props, {
+    element: Readonly<import('vue').ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    close: (event: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onClose?: (event: MouseEvent) => any;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;