@dxtmisha/d1 0.1.3 → 0.2.0

package/dist/D1SelectValue.vue_vue_type_script_setup_true_lang-CMmmYTxu.js

@@ -0,0 +1,53 @@
+import { defineComponent as p, computed as t, openBlock as m, createBlock as u, unref as d, mergeDefaults as f } from "vue";
+import "@dxtmisha/functional";
+import { defaultsSelectValue as _, SelectValueDesign as h } from "@dxtmisha/constructor/SelectValue";
+import { D as y } from "./index-BWfsjhQo.js";
+const k = {
+  ..._,
+  chipAttrs: {
+    size: "sm"
+  },
+  iconCancel: "close_small"
+}, g = /* @__PURE__ */ p({
+  name: "D1SelectValue",
+  __name: "D1SelectValue",
+  props: /* @__PURE__ */ f({
+    readonly: { type: Boolean },
+    disabled: { type: Boolean },
+    chipAttrs: {},
+    placeholder: {},
+    value: {},
+    multiple: { type: Boolean },
+    iconShow: { type: Boolean },
+    iconAttrs: {},
+    iconCancel: {}
+  }, k),
+  emits: ["click", "clickLite"],
+  setup(o, { expose: s, emit: c }) {
+    const l = c, n = o, a = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-selectValue": !0
+        // :classes-values [!] System label / Системная метка
+      }
+    })), r = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), e = new h(
+      "d1.selectValue",
+      n,
+      {
+        emits: l,
+        classes: a,
+        styles: r,
+        components: {
+          chip: y
+        }
+      }
+    ), i = e.render();
+    return s(e.expose()), (B, D) => (m(), u(d(i)));
+  }
+});
+export {
+  g as _
+};

package/dist/D1Skeleton.d.ts

@@ -0,0 +1,84 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { PublicProps } from 'vue';
+import { SkeletonPropsBasic } from '@dxtmisha/constructor/Skeleton';
+import { SkeletonSlots } from '@dxtmisha/constructor/Skeleton';
+
+declare const __VLS_component: DefineComponent<PropsToken, {
+    isActive: ComputedRef<boolean>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< PropsToken> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<SkeletonSlots> & SkeletonSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const D1Skeleton: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export declare type D1SkeletonProps = SkeletonPropsBasic & PropsToken;
+
+declare type PropsToken = {
+    active?: boolean;
+};
+
+export { }
+
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        D1Accordion: typeof D1Accordion;
+        D1ActionSheet: typeof D1ActionSheet;
+        D1Actions: typeof D1Actions;
+        D1Anchor: typeof D1Anchor;
+        D1Arrow: typeof D1Arrow;
+        D1Badge: typeof D1Badge;
+        D1Bars: typeof D1Bars;
+        D1Block: typeof D1Block;
+        D1Button: typeof D1Button;
+        D1Cell: typeof D1Cell;
+        D1Chip: typeof D1Chip;
+        D1ChipGroup: typeof D1ChipGroup;
+        D1Dialog: typeof D1Dialog;
+        D1Field: typeof D1Field;
+        D1FieldCounter: typeof D1FieldCounter;
+        D1FieldLabel: typeof D1FieldLabel;
+        D1FieldMessage: typeof D1FieldMessage;
+        D1Icon: typeof D1Icon;
+        D1Image: typeof D1Image;
+        D1Input: typeof D1Input;
+        D1List: typeof D1List;
+        D1ListGroup: typeof D1ListGroup;
+        D1ListItem: typeof D1ListItem;
+        D1ListMenu: typeof D1ListMenu;
+        D1Mask: typeof D1Mask;
+        D1Menu: typeof D1Menu;
+        D1Modal: typeof D1Modal;
+        D1MotionTransform: typeof D1MotionTransform;
+        D1Page: typeof D1Page;
+        D1Progress: typeof D1Progress;
+        D1Ripple: typeof D1Ripple;
+        D1Scrollbar: typeof D1Scrollbar;
+        D1Section: typeof D1Section;
+        D1Select: typeof D1Select;
+        D1SelectValue: typeof D1SelectValue;
+        D1Skeleton: typeof D1Skeleton;
+        D1TextareaAutosize: typeof D1TextareaAutosize;
+        D1Tooltip: typeof D1Tooltip;
+        D1Window: typeof D1Window;
+    }
+}

package/dist/D1Skeleton.js

@@ -0,0 +1,4 @@
+import { _ as r } from "./D1Skeleton.vue_vue_type_script_setup_true_lang-DQ8Fj5xO.js";
+export {
+  r as D1Skeleton
+};

package/dist/D1Skeleton.vue_vue_type_script_setup_true_lang-DQ8Fj5xO.js

@@ -0,0 +1,37 @@
+import { defineComponent as m, computed as o, openBlock as i, createBlock as k, unref as d, mergeDefaults as u } from "vue";
+import "@dxtmisha/functional";
+import { defaultsSkeleton as f, SkeletonDesign as _ } from "@dxtmisha/constructor/Skeleton";
+const x = {
+  ...f
+}, B = /* @__PURE__ */ m({
+  name: "D1Skeleton",
+  __name: "D1Skeleton",
+  props: /* @__PURE__ */ u({
+    active: { type: Boolean }
+  }, x),
+  setup(n, { expose: s, emit: c }) {
+    const r = c, e = n, l = o(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-skeleton": !0,
+        "d1-skeleton--active": e.active
+        // :classes-values [!] System label / Системная метка
+      }
+    })), a = o(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), t = new _(
+      "d1.skeleton",
+      e,
+      {
+        emits: r,
+        classes: l,
+        styles: a
+      }
+    ), p = t.render();
+    return s(t.expose()), (D, S) => (i(), k(d(p)));
+  }
+});
+export {
+  B as _
+};

package/dist/D1TextareaAutosize.d.ts

@@ -0,0 +1,88 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { TextareaAutosizePropsBasic } from '@dxtmisha/constructor/TextareaAutosize';
+import { TextareaAutosizeSlots } from '@dxtmisha/constructor/TextareaAutosize';
+
+declare const __VLS_component: DefineComponent<D1TextareaAutosizeProps, {
+    value: Ref<string>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    input: (event: InputEvent) => any;
+}, string, PublicProps, Readonly<D1TextareaAutosizeProps> & Readonly<{
+    onInput?: ((event: InputEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TextareaAutosizeSlots> & TextareaAutosizeSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const D1TextareaAutosize: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export declare type D1TextareaAutosizeProps = TextareaAutosizePropsBasic & PropsToken;
+
+declare type PropsToken = {
+    height?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+};
+
+export { }
+
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        D1Accordion: typeof D1Accordion;
+        D1ActionSheet: typeof D1ActionSheet;
+        D1Actions: typeof D1Actions;
+        D1Anchor: typeof D1Anchor;
+        D1Arrow: typeof D1Arrow;
+        D1Badge: typeof D1Badge;
+        D1Bars: typeof D1Bars;
+        D1Block: typeof D1Block;
+        D1Button: typeof D1Button;
+        D1Cell: typeof D1Cell;
+        D1Chip: typeof D1Chip;
+        D1ChipGroup: typeof D1ChipGroup;
+        D1Dialog: typeof D1Dialog;
+        D1Field: typeof D1Field;
+        D1FieldCounter: typeof D1FieldCounter;
+        D1FieldLabel: typeof D1FieldLabel;
+        D1FieldMessage: typeof D1FieldMessage;
+        D1Icon: typeof D1Icon;
+        D1Image: typeof D1Image;
+        D1Input: typeof D1Input;
+        D1List: typeof D1List;
+        D1ListGroup: typeof D1ListGroup;
+        D1ListItem: typeof D1ListItem;
+        D1ListMenu: typeof D1ListMenu;
+        D1Mask: typeof D1Mask;
+        D1Menu: typeof D1Menu;
+        D1Modal: typeof D1Modal;
+        D1MotionTransform: typeof D1MotionTransform;
+        D1Page: typeof D1Page;
+        D1Progress: typeof D1Progress;
+        D1Ripple: typeof D1Ripple;
+        D1Scrollbar: typeof D1Scrollbar;
+        D1Section: typeof D1Section;
+        D1Select: typeof D1Select;
+        D1SelectValue: typeof D1SelectValue;
+        D1Skeleton: typeof D1Skeleton;
+        D1TextareaAutosize: typeof D1TextareaAutosize;
+        D1Tooltip: typeof D1Tooltip;
+        D1Window: typeof D1Window;
+    }
+}

package/dist/D1TextareaAutosize.js

@@ -0,0 +1,4 @@
+import { _ as o } from "./D1TextareaAutosize.vue_vue_type_script_setup_true_lang-DjisVn_e.js";
+export {
+  o as D1TextareaAutosize
+};

package/dist/D1TextareaAutosize.vue_vue_type_script_setup_true_lang-DjisVn_e.js

@@ -0,0 +1,47 @@
+import { defineComponent as m, computed as s, openBlock as p, createBlock as h, unref as l, mergeDefaults as x } from "vue";
+import { inArray as d } from "@dxtmisha/functional";
+import { defaultsTextareaAutosize as g, TextareaAutosizeDesign as f } from "@dxtmisha/constructor/TextareaAutosize";
+const A = {
+  // :values [!] System label / Системная метка
+  height: ["xs", "sm", "md", "lg", "xl"]
+  // :values [!] System label / Системная метка
+}, z = {
+  ...g,
+  // :default [!] System label / Системная метка
+  height: "md"
+}, B = /* @__PURE__ */ m({
+  name: "D1TextareaAutosize",
+  __name: "D1TextareaAutosize",
+  props: /* @__PURE__ */ x({
+    value: {},
+    autosize: { type: Boolean },
+    inputAttrs: {},
+    height: {}
+  }, z),
+  emits: ["input"],
+  setup(o, { expose: r, emit: a }) {
+    const n = a, e = o, i = s(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-textareaAutosize": !0,
+        [`d1-textareaAutosize--height--${e.height}`]: d(A.height, e.height)
+        // :classes-values [!] System label / Системная метка
+      }
+    })), u = s(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), t = new f(
+      "d1.textareaAutosize",
+      e,
+      {
+        emits: n,
+        classes: i,
+        styles: u
+      }
+    ), c = t.render();
+    return r(t.expose()), (_, T) => (p(), h(l(c)));
+  }
+});
+export {
+  B as _
+};

package/dist/D1Tooltip.d.ts

@@ -0,0 +1,89 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { DefineComponent } from 'vue';
+import { PublicProps } from 'vue';
+import { TooltipPropsBasic } from '@dxtmisha/constructor/Tooltip';
+import { TooltipSlots } from '@dxtmisha/constructor/Tooltip';
+
+declare const __VLS_component: DefineComponent<D1TooltipProps, {
+    toggle(open: boolean, flash?: boolean): Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    tooltip: (open: boolean) => any;
+}, string, PublicProps, Readonly<D1TooltipProps> & Readonly<{
+    onTooltip?: ((open: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<TooltipSlots> & TooltipSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const D1Tooltip: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export declare type D1TooltipProps = TooltipPropsBasic & PropsToken;
+
+declare type PropsToken = {
+    interactive?: boolean;
+    embedded?: boolean;
+    maxWidth?: 'sm' | 'md' | 'lg';
+};
+
+export { }
+
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        D1Accordion: typeof D1Accordion;
+        D1ActionSheet: typeof D1ActionSheet;
+        D1Actions: typeof D1Actions;
+        D1Anchor: typeof D1Anchor;
+        D1Arrow: typeof D1Arrow;
+        D1Badge: typeof D1Badge;
+        D1Bars: typeof D1Bars;
+        D1Block: typeof D1Block;
+        D1Button: typeof D1Button;
+        D1Cell: typeof D1Cell;
+        D1Chip: typeof D1Chip;
+        D1ChipGroup: typeof D1ChipGroup;
+        D1Dialog: typeof D1Dialog;
+        D1Field: typeof D1Field;
+        D1FieldCounter: typeof D1FieldCounter;
+        D1FieldLabel: typeof D1FieldLabel;
+        D1FieldMessage: typeof D1FieldMessage;
+        D1Icon: typeof D1Icon;
+        D1Image: typeof D1Image;
+        D1Input: typeof D1Input;
+        D1List: typeof D1List;
+        D1ListGroup: typeof D1ListGroup;
+        D1ListItem: typeof D1ListItem;
+        D1ListMenu: typeof D1ListMenu;
+        D1Mask: typeof D1Mask;
+        D1Menu: typeof D1Menu;
+        D1Modal: typeof D1Modal;
+        D1MotionTransform: typeof D1MotionTransform;
+        D1Page: typeof D1Page;
+        D1Progress: typeof D1Progress;
+        D1Ripple: typeof D1Ripple;
+        D1Scrollbar: typeof D1Scrollbar;
+        D1Section: typeof D1Section;
+        D1Select: typeof D1Select;
+        D1SelectValue: typeof D1SelectValue;
+        D1Skeleton: typeof D1Skeleton;
+        D1TextareaAutosize: typeof D1TextareaAutosize;
+        D1Tooltip: typeof D1Tooltip;
+        D1Window: typeof D1Window;
+    }
+}

package/dist/D1Tooltip.js

@@ -0,0 +1,4 @@
+import { _ as r } from "./D1Tooltip.vue_vue_type_script_setup_true_lang-CYtDl5uG.js";
+export {
+  r as D1Tooltip
+};

package/dist/D1Tooltip.vue_vue_type_script_setup_true_lang-CYtDl5uG.js

@@ -0,0 +1,67 @@
+import { defineComponent as l, computed as t, openBlock as m, createBlock as c, unref as y, mergeDefaults as f } from "vue";
+import { inArray as u } from "@dxtmisha/functional";
+import { defaultsTooltip as x, TooltipDesign as _ } from "@dxtmisha/constructor/Tooltip";
+import { _ as h } from "./D1Arrow.vue_vue_type_script_setup_true_lang-CL7CgsNP.js";
+const B = h, w = {
+  // :values [!] System label / Системная метка
+  maxWidth: ["sm", "md", "lg"]
+  // :values [!] System label / Системная метка
+}, W = {
+  ...x,
+  // :default [!] System label / Системная метка
+  interactive: !0,
+  maxWidth: "md"
+}, A = /* @__PURE__ */ l({
+  name: "D1Tooltip",
+  __name: "D1Tooltip",
+  props: /* @__PURE__ */ f({
+    label: {},
+    labelId: {},
+    description: {},
+    descriptionId: {},
+    arrowShow: { type: Boolean },
+    arrowPosition: {},
+    arrowAttrs: {},
+    open: { type: Boolean },
+    disabled: { type: Boolean },
+    inDom: { type: Boolean },
+    top: { type: Boolean },
+    indent: {},
+    delay: {},
+    delayHide: {},
+    embedded: { type: Boolean },
+    interactive: { type: Boolean },
+    maxWidth: {}
+  }, W),
+  emits: ["tooltip"],
+  setup(n, { expose: i, emit: s }) {
+    const r = s, e = n, a = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-tooltip": !0,
+        "d1-tooltip--interactive": e.interactive,
+        "d1-tooltip--embedded": e.embedded,
+        [`d1-tooltip--maxWidth--${e.maxWidth}`]: u(w.maxWidth, e.maxWidth)
+        // :classes-values [!] System label / Системная метка
+      }
+    })), d = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new _(
+      "d1.tooltip",
+      e,
+      {
+        emits: r,
+        classes: a,
+        styles: d,
+        components: {
+          arrow: B
+        }
+      }
+    ), p = o.render();
+    return i(o.expose()), (b, D) => (m(), c(y(p)));
+  }
+});
+export {
+  A as _
+};

package/dist/D1Window.d.ts

@@ -0,0 +1,190 @@
+import { ComponentOptionsMixin } from 'vue';
+import { ComponentProvideOptions } from 'vue';
+import { ComputedRef } from 'vue';
+import { DefineComponent } from 'vue';
+import { IconPropsBasic } from '@dxtmisha/constructor/Icon';
+import { ImageEventData } from '@dxtmisha/constructor/Image';
+import { ImagePropsBasic } from '@dxtmisha/constructor/Image';
+import { PublicProps } from 'vue';
+import { Ref } from 'vue';
+import { ScrollbarEdgeType } from '@dxtmisha/constructor/Scrollbar';
+import { ScrollbarPropsBasic } from '@dxtmisha/constructor/Scrollbar';
+import { WindowControlItem } from '@dxtmisha/constructor/Window';
+import { WindowEmitOptions } from '@dxtmisha/constructor/Window';
+import { WindowPropsBasic } from '@dxtmisha/constructor/Window';
+import { WindowSlots } from '@dxtmisha/constructor/Window';
+
+declare const __VLS_component: DefineComponent<D1WindowProps, {
+    id: string;
+    open: Ref<boolean>;
+    control: ComputedRef<WindowControlItem>;
+    setOpen(open: boolean): Promise<void>;
+    toOpen(): Promise<void>;
+    toClose(): Promise<void>;
+    toggle(): Promise<void>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    load: (image: ImageEventData) => any;
+    window: (options: WindowEmitOptions) => any;
+    "update:open": (value: boolean) => any;
+    "update:modelOpen": (value: boolean) => any;
+    scrollbarTop: (isTop: boolean) => any;
+    scrollbarReachTop: () => any;
+    scrollbarLeaveTop: () => any;
+    scrollbarBottom: (isBottom: boolean) => any;
+    scrollbarReachBottom: () => any;
+    scrollbarLeaveBottom: () => any;
+    scrollbarEdge: (isTop: boolean, isBottom: boolean, edge: ScrollbarEdgeType) => any;
+}, string, PublicProps, Readonly<D1WindowProps> & Readonly<{
+    onLoad?: ((image: ImageEventData) => any) | undefined;
+    onWindow?: ((options: WindowEmitOptions) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelOpen"?: ((value: boolean) => any) | undefined;
+    onScrollbarTop?: ((isTop: boolean) => any) | undefined;
+    onScrollbarReachTop?: (() => any) | undefined;
+    onScrollbarLeaveTop?: (() => any) | undefined;
+    onScrollbarBottom?: ((isBottom: boolean) => any) | undefined;
+    onScrollbarReachBottom?: (() => any) | undefined;
+    onScrollbarLeaveBottom?: (() => any) | undefined;
+    onScrollbarEdge?: ((isTop: boolean, isBottom: boolean, edge: ScrollbarEdgeType) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<WindowSlots> & WindowSlots;
+    refs: {};
+    rootEl: any;
+};
+
+declare type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+
+declare type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+
+export declare const D1Window: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export declare type D1WindowProps = WindowPropsBasic<ScrollbarProps, IconProps, ImageProps> & PropsToken_4;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type IconProps = IconPropsBasic<ImageProps> & PropsToken_3;
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type ImageProps = ImagePropsBasic & PropsToken_2;
+
+declare type PropsToken = {
+    visible?: boolean;
+    divider?: boolean;
+    dividerTop?: boolean;
+    dividerBottom?: boolean;
+    dividerHide?: boolean;
+    inverse?: boolean;
+    standard?: boolean;
+};
+
+declare type PropsToken_2 = {
+    turn?: boolean;
+    disabled?: boolean;
+    hide?: boolean;
+    adaptive?: boolean;
+    size?: 'auto' | 'contain' | 'cover';
+};
+
+declare type PropsToken_3 = {
+    turn?: boolean;
+    disabled?: boolean;
+    hide?: boolean;
+    asPalette?: boolean;
+    dir?: boolean;
+    overlay?: boolean;
+    dynamic?: boolean;
+    start?: boolean;
+    end?: boolean;
+    high?: boolean;
+    animationType?: 'type1' | 'type2';
+    animationShow?: boolean;
+    square?: boolean;
+    circle?: boolean;
+    rect?: boolean;
+    size?: 'auto' | 'x' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl' | '4xl' | '5xl' | '6xl' | '7xl' | '8xl' | '9xl';
+    inverse?: boolean;
+    rounded?: 'auto' | 'sm' | 'md' | 'lg' | 'xl' | 'full';
+};
+
+declare type PropsToken_4 = {
+    width?: string | 'auto' | 'max' | 'sm' | 'md' | 'lg' | 'custom';
+    height?: string | 'auto' | 'max' | 'sm' | 'md' | 'lg' | 'custom';
+    hide?: boolean;
+    axis?: 'x' | 'y' | 'on';
+    imagePosition?: 'top' | 'left';
+    dense?: boolean;
+    alignment?: 'center' | 'top' | 'topRight' | 'topLeft' | 'topFull' | 'right' | 'rightFull' | 'bottom' | 'bottomRight' | 'bottomLeft' | 'bottomFull' | 'left' | 'leftFull';
+    origin?: 'center' | 'top' | 'right' | 'bottom' | 'left' | 'topToBottom' | 'rightToLeft' | 'bottomToTop' | 'leftToRight';
+    adaptive?: 'menu' | 'menuWindow' | 'modal' | 'modalDynamic' | 'actionSheetRight' | 'actionSheetBottom' | 'static' | 'actionSheet' | 'actionSheetToModal' | 'autoStaticSm' | 'autoStaticMd' | 'autoStaticLg' | 'autoStaticXl' | 'autoStatic2xl';
+    fullscreen?: boolean;
+    overscroll?: boolean;
+    closeButton?: boolean;
+    closeMobileHide?: boolean;
+    widthMatch?: boolean;
+    imageSize?: 'sm' | 'md' | 'lg' | 'quarter' | 'half';
+};
+
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+declare type ScrollbarProps = ScrollbarPropsBasic & PropsToken;
+
+export { }
+
+
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        D1Accordion: typeof D1Accordion;
+        D1ActionSheet: typeof D1ActionSheet;
+        D1Actions: typeof D1Actions;
+        D1Anchor: typeof D1Anchor;
+        D1Arrow: typeof D1Arrow;
+        D1Badge: typeof D1Badge;
+        D1Bars: typeof D1Bars;
+        D1Block: typeof D1Block;
+        D1Button: typeof D1Button;
+        D1Cell: typeof D1Cell;
+        D1Chip: typeof D1Chip;
+        D1ChipGroup: typeof D1ChipGroup;
+        D1Dialog: typeof D1Dialog;
+        D1Field: typeof D1Field;
+        D1FieldCounter: typeof D1FieldCounter;
+        D1FieldLabel: typeof D1FieldLabel;
+        D1FieldMessage: typeof D1FieldMessage;
+        D1Icon: typeof D1Icon;
+        D1Image: typeof D1Image;
+        D1Input: typeof D1Input;
+        D1List: typeof D1List;
+        D1ListGroup: typeof D1ListGroup;
+        D1ListItem: typeof D1ListItem;
+        D1ListMenu: typeof D1ListMenu;
+        D1Mask: typeof D1Mask;
+        D1Menu: typeof D1Menu;
+        D1Modal: typeof D1Modal;
+        D1MotionTransform: typeof D1MotionTransform;
+        D1Page: typeof D1Page;
+        D1Progress: typeof D1Progress;
+        D1Ripple: typeof D1Ripple;
+        D1Scrollbar: typeof D1Scrollbar;
+        D1Section: typeof D1Section;
+        D1Select: typeof D1Select;
+        D1SelectValue: typeof D1SelectValue;
+        D1Skeleton: typeof D1Skeleton;
+        D1TextareaAutosize: typeof D1TextareaAutosize;
+        D1Tooltip: typeof D1Tooltip;
+        D1Window: typeof D1Window;
+    }
+}

package/dist/D1Window.js

@@ -0,0 +1,4 @@
+import { _ as a } from "./D1Window.vue_vue_type_script_setup_true_lang-Bhz5VvjK.js";
+export {
+  a as D1Window
+};