@dxtmisha/d1 0.1.0

package/README.md

@@ -0,0 +1 @@
+# D1

package/dist/App.vue.d.ts

@@ -0,0 +1,3 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLElement>;
+export default _default;

package/dist/D1Accordion.js

@@ -0,0 +1,396 @@
+import { defineComponent as c, mergeDefaults as m, computed as t, createBlock as y, openBlock as u, unref as g } from "vue";
+import { inArray as n } from "@dxtmisha/functional";
+import { defaultsAccordion as b, AccordionDesign as D } from "@dxtmisha/constructor/Accordion";
+import { defaultsCell as k, CellDesign as $ } from "@dxtmisha/constructor/Cell";
+import { defaultsIcon as h, IconDesign as w } from "@dxtmisha/constructor/Icon";
+import { D as L } from "./index-BWyEZpKM.js";
+import { defaultsProgress as P, ProgressDesign as z } from "@dxtmisha/constructor/Progress";
+import { defaultsRipple as I, RippleDesign as A } from "@dxtmisha/constructor/Ripple";
+import { defaultsMotionTransform as H, MotionTransformDesign as S } from "@dxtmisha/constructor/MotionTransform";
+const T = {
+  // :values [!] System label / Системная метка
+  animationType: ["type1", "type2"],
+  size: ["auto", "x", "xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "5xl", "6xl", "7xl", "8xl", "9xl"],
+  rounded: ["auto", "sm", "md", "lg", "xl", "full"]
+  // :values [!] System label / Системная метка
+}, M = {
+  ...h,
+  // :default [!] System label / Системная метка
+  animationType: "type1",
+  square: !0,
+  size: "auto",
+  rounded: "auto"
+}, O = /* @__PURE__ */ c({
+  name: "D1Icon",
+  __name: "D1Icon",
+  props: /* @__PURE__ */ m({
+    isSkeleton: { type: Boolean },
+    ariaLabel: {},
+    active: { type: Boolean },
+    icon: {},
+    iconActive: {},
+    role: {},
+    turn: { type: Boolean },
+    disabled: { type: Boolean },
+    hide: { type: Boolean },
+    asPalette: { type: Boolean },
+    dir: { type: Boolean },
+    overlay: { type: Boolean },
+    dynamic: { type: Boolean },
+    start: { type: Boolean },
+    end: { type: Boolean },
+    high: { type: Boolean },
+    animationType: {},
+    animationShow: { type: Boolean },
+    square: { type: Boolean },
+    circle: { type: Boolean },
+    rect: { type: Boolean },
+    size: {},
+    inverse: { type: Boolean },
+    rounded: {}
+  }, M),
+  emits: ["load"],
+  setup(i, { expose: a, emit: s }) {
+    const d = s, e = i, r = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-icon": !0,
+        "d1-icon--turn": e.turn,
+        "d1-icon--disabled": e.disabled,
+        "d1-icon--hide": e.hide,
+        "d1-icon--asPalette": e.asPalette,
+        "d1-icon--dir": e.dir,
+        "d1-icon--overlay": e.overlay,
+        "d1-icon--dynamic": e.dynamic,
+        "d1-icon--start": e.start,
+        "d1-icon--end": e.end,
+        "d1-icon--high": e.high,
+        [`d1-icon--animationType--${e.animationType}`]: n(T.animationType, e.animationType),
+        "d1-icon--animationShow": e.animationShow,
+        "d1-icon--square": e.square && !e.circle && !e.rect,
+        "d1-icon--circle": e.circle,
+        "d1-icon--rect": e.rect,
+        [`d1-icon--size--${e.size}`]: n(T.size, e.size),
+        "d1-icon--inverse": e.inverse,
+        [`d1-icon--rounded--${e.rounded}`]: n(T.rounded, e.rounded)
+        // :classes-values [!] System label / Системная метка
+      }
+    })), l = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new w(
+      "d1.icon",
+      e,
+      {
+        emits: d,
+        components: {
+          image: L
+        },
+        classes: r,
+        styles: l
+      }
+    ), p = o.render();
+    return a(o.expose()), (B, f) => (u(), y(g(p)));
+  }
+}), v = {
+  // :values [!] System label / Системная метка
+  indeterminate: ["type1", "type2", "type3"],
+  position: ["top", "bottom", "static"],
+  size: ["sm", "md", "lg"],
+  palette: ["red", "orange", "amber", "yellow", "lime", "green", "emerald", "teal", "cyan", "sky", "blue", "indigo", "violet", "purple", "fuchsia", "pink", "rose", "slate", "gray", "zinc", "neutral", "stone", "black", "white"]
+  // :values [!] System label / Системная метка
+}, C = {
+  ...P,
+  // :default [!] System label / Системная метка
+  linear: !0,
+  indeterminate: "type1",
+  position: "top",
+  size: "md"
+}, V = /* @__PURE__ */ c({
+  name: "D1Progress",
+  __name: "D1Progress",
+  props: /* @__PURE__ */ m({
+    ariaLabel: {},
+    ariaLive: {},
+    visible: { type: Boolean },
+    value: {},
+    max: {},
+    linear: { type: Boolean },
+    circular: { type: Boolean },
+    point: { type: Boolean },
+    delay: {},
+    delayHide: {},
+    indeterminate: {},
+    position: {},
+    dense: { type: Boolean },
+    inverse: { type: Boolean },
+    size: {},
+    palette: {}
+  }, C),
+  setup(i, { expose: a, emit: s }) {
+    const d = s, e = i, r = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-progress": !0,
+        "d1-progress--point": e.point,
+        "d1-progress--linear": e.linear && !e.circular,
+        "d1-progress--circular": e.circular,
+        [`d1-progress--indeterminate--${e.indeterminate}`]: n(v.indeterminate, e.indeterminate),
+        [`d1-progress--position--${e.position}`]: n(v.position, e.position),
+        "d1-progress--dense": e.dense,
+        "d1-progress--inverse": e.inverse,
+        [`d1-progress--size--${e.size}`]: n(v.size, e.size),
+        [`d1-palette d1-palette--${e.palette}`]: n(v.palette, e.palette)
+        // :classes-values [!] System label / Системная метка
+      }
+    })), l = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new z(
+      "d1.progress",
+      e,
+      {
+        emits: d,
+        classes: r,
+        styles: l
+      }
+    ), p = o.render();
+    return a(o.expose()), (B, f) => (u(), y(g(p)));
+  }
+}), q = {
+  ...I
+}, F = /* @__PURE__ */ c({
+  name: "D1Ripple",
+  __name: "D1Ripple",
+  props: /* @__PURE__ */ m({
+    disabled: { type: Boolean }
+  }, q),
+  setup(i, { expose: a, emit: s }) {
+    const d = s, e = i, r = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-ripple": !0
+        // :classes-values [!] System label / Системная метка
+      }
+    })), l = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new A(
+      "d1.ripple",
+      e,
+      {
+        emits: d,
+        classes: r,
+        styles: l
+      }
+    ), p = o.render();
+    return a(o.expose()), (B, f) => (u(), y(g(p)));
+  }
+}), _ = {
+  // :values [!] System label / Системная метка
+  dividerLabel: ["always", "none", "adaptiveSm", "adaptiveMd", "adaptiveLg", "adaptiveXl", "adaptive2xl", "containerSm", "containerMd", "containerLg", "containerXl", "container2xl"],
+  padding: ["sm", "md", "lg", "ySm", "yMd", "yLg", "none"]
+  // :values [!] System label / Системная метка
+}, R = {
+  ...k,
+  // :default [!] System label / Системная метка
+  divider: !0,
+  padding: "none",
+  paddingByIndent: !0
+}, U = /* @__PURE__ */ c({
+  name: "D1Cell",
+  __name: "D1Cell",
+  props: /* @__PURE__ */ m({
+    label: {},
+    labelId: {},
+    description: {},
+    caption: {},
+    readonly: { type: Boolean },
+    disabled: { type: Boolean },
+    icon: {},
+    selected: { type: Boolean },
+    iconTurn: { type: Boolean },
+    iconHide: { type: Boolean },
+    iconDir: { type: Boolean },
+    iconPalette: { type: Boolean },
+    iconAttrs: {},
+    iconTrailing: {},
+    iconTrailingTurnOnly: { type: Boolean },
+    iconTrailingDirOnly: { type: Boolean },
+    iconTrailingPalette: { type: Boolean },
+    loading: { type: [Boolean, Object] },
+    isSkeleton: { type: Boolean },
+    to: {},
+    value: {},
+    detail: {},
+    role: {},
+    tag: {},
+    divider: { type: Boolean },
+    dynamic: { type: Boolean },
+    focus: { type: Boolean },
+    dynamicHover: { type: Boolean },
+    dividerLabel: {},
+    iconTop: { type: Boolean },
+    padding: {},
+    paddingByIndent: { type: Boolean }
+  }, R),
+  emits: ["click", "clickLite"],
+  setup(i, { expose: a, emit: s }) {
+    const d = s, e = i, r = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-cell": !0,
+        "d1-cell--focus": e.focus,
+        "d1-cell--selected": e.selected,
+        "d1-cell--readonly": e.readonly,
+        "d1-cell--disabled": e.disabled,
+        "d1-cell--dynamic": e.dynamic,
+        "d1-cell--dynamicHover": e.dynamicHover,
+        "d1-cell--divider": e.divider,
+        [`d1-cell--dividerLabel--${e.dividerLabel}`]: n(_.dividerLabel, e.dividerLabel),
+        "d1-cell--iconTop": e.iconTop,
+        [`d1-cell--padding--${e.padding}`]: n(_.padding, e.padding),
+        "d1-cell--paddingByIndent": e.paddingByIndent
+        // :classes-values [!] System label / Системная метка
+      }
+    })), l = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new $(
+      "d1.cell",
+      e,
+      {
+        emits: d,
+        classes: r,
+        styles: l,
+        components: {
+          icon: O,
+          progress: V,
+          ripple: F
+        }
+      }
+    ), p = o.render();
+    return a(o.expose()), (B, f) => (u(), y(g(p)));
+  }
+}), X = U, x = {
+  // :values [!] System label / Системная метка
+  animationHeadPosition: ["top", "toBottom"],
+  adaptive: ["planeAlways", "planeSm", "planeMd", "planeLg", "planeXl", "plane2xl"]
+  // :values [!] System label / Системная метка
+}, j = {
+  ...H,
+  // :default [!] System label / Системная метка
+  animationHeadPosition: "top",
+  adaptive: "planeMd"
+}, E = /* @__PURE__ */ c({
+  name: "D1MotionTransform",
+  __name: "D1MotionTransform",
+  props: /* @__PURE__ */ m({
+    role: {},
+    ariaLabelledby: {},
+    ariaDescribedby: {},
+    open: { type: Boolean },
+    inDom: { type: Boolean },
+    ignore: {},
+    ignoreSelector: {},
+    clickOpen: { type: Boolean },
+    autoClose: { type: Boolean },
+    animationShow: { type: Boolean },
+    tagBody: {},
+    modelOpen: { type: Boolean },
+    "onUpdate:open": { type: Function },
+    "onUpdate:modelOpen": { type: Function },
+    section: { type: Boolean },
+    animationHeadPosition: {},
+    adaptive: {}
+  }, j),
+  emits: ["transform", "transformLite", "update:open", "update:modelOpen"],
+  setup(i, { expose: a, emit: s }) {
+    const d = s, e = i, r = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-motionTransform": !0,
+        "d1-motionTransform--section": e.section,
+        [`d1-motionTransform--animationHeadPosition--${e.animationHeadPosition}`]: n(x.animationHeadPosition, e.animationHeadPosition),
+        [`d1-motionTransform--adaptive--${e.adaptive}`]: n(x.adaptive, e.adaptive)
+        // :classes-values [!] System label / Системная метка
+      }
+    })), l = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new S(
+      "d1.motionTransform",
+      e,
+      {
+        emits: d,
+        classes: r,
+        styles: l
+      }
+    ), p = o.render();
+    return a(o.expose()), (B, f) => (u(), y(g(p)));
+  }
+}), G = E, J = {
+  // :values [!] System label / Системная метка
+  padding: ["sm", "md", "lg", "ySm", "yMd", "yLg", "none"]
+  // :values [!] System label / Системная метка
+}, K = {
+  ...b,
+  iconArrowDown: "keyboard_arrow_down",
+  // :default [!] System label / Системная метка
+  divider: !0,
+  padding: "none",
+  paddingByIndent: !0
+}, ie = /* @__PURE__ */ c({
+  name: "D1Accordion",
+  __name: "D1Accordion",
+  props: /* @__PURE__ */ m({
+    label: {},
+    labelId: {},
+    description: {},
+    icon: {},
+    open: { type: Boolean },
+    clickOpen: { type: Boolean },
+    autoClose: { type: Boolean },
+    motionTransformAttrs: {},
+    cellAttrs: {},
+    iconArrowDown: {},
+    modelOpen: { type: Boolean },
+    "onUpdate:open": { type: Function },
+    "onUpdate:modelOpen": { type: Function },
+    divider: { type: Boolean },
+    padding: {},
+    paddingByIndent: { type: Boolean }
+  }, K),
+  emits: ["click", "clickLite", "transform", "transformLite", "update:open", "update:modelOpen"],
+  setup(i, { expose: a, emit: s }) {
+    const d = s, e = i, r = t(() => ({
+      main: {
+        // :classes-values [!] System label / Системная метка
+        "d1-accordion": !0,
+        "d1-accordion--divider": e.divider,
+        [`d1-accordion--padding--${e.padding}`]: n(J.padding, e.padding),
+        "d1-accordion--paddingByIndent": e.paddingByIndent
+        // :classes-values [!] System label / Системная метка
+      }
+    })), l = t(() => ({
+      // :styles-values [!] System label / Системная метка
+      // :styles-values [!] System label / Системная метка
+    })), o = new D(
+      "d1.accordion",
+      e,
+      {
+        emits: d,
+        classes: r,
+        styles: l,
+        components: {
+          cell: X,
+          motionTransform: G
+        }
+      }
+    ), p = o.render();
+    return a(o.expose()), (B, f) => (u(), y(g(p)));
+  }
+});
+export {
+  ie as D1Accordion
+};

package/dist/D1Image.js

@@ -0,0 +1,4 @@
+import { D as m } from "./index-BWyEZpKM.js";
+export {
+  m as D1Image
+};

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

@@ -0,0 +1,3 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<{}, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, HTMLElement>;
+export default _default;

package/dist/components/Ui/Accordion/D1Accordion.vue.d.ts

@@ -0,0 +1,43 @@
+import { AccordionSlots } from '@dxtmisha/constructor/Accordion';
+import { AccordionProps } from './props';
+import { DefineComponent, Ref, ComputedRef, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { ConstrBind } from '@dxtmisha/functional';
+import { MotionTransformExpose, MotionTransformEmitOptions } from '@dxtmisha/constructor/MotionTransform';
+import { EventClickValue } from '@dxtmisha/constructor';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AccordionSlots> & AccordionSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<AccordionProps, {
+    motionTransformElement: Ref< ConstrBind<MotionTransformExpose> | undefined>;
+    open: Ref<boolean>;
+    isShow: ComputedRef<boolean>;
+    setOpen(open: boolean): void;
+    toOpen(): void;
+    toClose(): void;
+    toggle(): void;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    click: (event: MouseEvent, value: EventClickValue) => any;
+    clickLite: (value: EventClickValue) => any;
+    transform: (event: Event | undefined, options: MotionTransformEmitOptions) => any;
+    transformLite: (options: MotionTransformEmitOptions) => any;
+    "update:open": (value: boolean) => any;
+    "update:modelOpen": (value: boolean) => any;
+}, string, PublicProps, Readonly<AccordionProps> & Readonly<{
+    onClick?: ((event: MouseEvent, value: EventClickValue) => any) | undefined;
+    onClickLite?: ((value: EventClickValue) => any) | undefined;
+    onTransform?: ((event: Event | undefined, options: MotionTransformEmitOptions) => any) | undefined;
+    onTransformLite?: ((options: MotionTransformEmitOptions) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+    "onUpdate:modelOpen"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Ui/Accordion/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineSetupFnComponent, ShortEmitsToObject, SlotsType } from 'vue';
+import { AccordionEmits, AccordionSlots } from '@dxtmisha/constructor/Accordion';
+import { AccordionProps } from './props';
+export type { AccordionProps } from './props';
+export declare const D1Accordion: DefineSetupFnComponent<AccordionProps, ShortEmitsToObject<AccordionEmits>, SlotsType<AccordionSlots>>;

package/dist/components/Ui/Accordion/props.d.ts

@@ -0,0 +1,20 @@
+import { AccordionPropsBasic } from '@dxtmisha/constructor/Accordion';
+import { IconProps } from '../Icon';
+import { CellProps } from '../Cell';
+import { MotionTransformProps } from '../MotionTransform';
+export declare const propsValues: {
+    padding: string[];
+};
+export type PropsToken = {
+    divider?: boolean;
+    padding?: 'sm' | 'md' | 'lg' | 'ySm' | 'yMd' | 'yLg' | 'none';
+    paddingByIndent?: boolean;
+};
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export type AccordionProps = AccordionPropsBasic<IconProps, CellProps, MotionTransformProps> & PropsToken;
+/**
+ * Default value for property/ Значение по умолчанию для свойства
+ */
+export declare const defaults: object;

package/dist/components/Ui/Accordion/wiki.d.ts

@@ -0,0 +1,2 @@
+import { WikiStorybook } from '@dxtmisha/wiki';
+export declare const AccordionWikiStorybook: WikiStorybook;

package/dist/components/Ui/ActionSheet/D1ActionSheet.vue.d.ts

@@ -0,0 +1,44 @@
+import { ActionSheetSlots } from '@dxtmisha/constructor/ActionSheet';
+import { ActionSheetProps } from './props';
+import { DefineComponent, ComputedRef, Ref, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { WindowControlItem, WindowExpose, WindowEmitOptions } from '@dxtmisha/constructor/Window';
+import { ConstrBind } from '@dxtmisha/functional';
+import { EventClickValue } from '@dxtmisha/constructor';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<ActionSheetSlots> & ActionSheetSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ActionSheetProps, {
+    id: ComputedRef<string | undefined>;
+    open: ComputedRef<boolean>;
+    control: ComputedRef< WindowControlItem | undefined>;
+    setOpen: WindowExpose["setOpen"];
+    toOpen: WindowExpose["toOpen"];
+    toClose: WindowExpose["toClose"];
+    toggle: WindowExpose["toggle"];
+    windowElement: Ref< ConstrBind<WindowExpose> | undefined>;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    window: (options: WindowEmitOptions) => any;
+    bars: (event: MouseEvent, value: EventClickValue) => any;
+    barsLite: (value: EventClickValue) => any;
+    barsBack: (value: EventClickValue) => any;
+    actions: (event: MouseEvent, value: EventClickValue) => any;
+    actionsLite: (value: EventClickValue) => any;
+}, string, PublicProps, Readonly<ActionSheetProps> & Readonly<{
+    onWindow?: ((options: WindowEmitOptions) => any) | undefined;
+    onBars?: ((event: MouseEvent, value: EventClickValue) => any) | undefined;
+    onBarsLite?: ((value: EventClickValue) => any) | undefined;
+    onBarsBack?: ((value: EventClickValue) => any) | undefined;
+    onActions?: ((event: MouseEvent, value: EventClickValue) => any) | undefined;
+    onActionsLite?: ((value: EventClickValue) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Ui/ActionSheet/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineSetupFnComponent, ShortEmitsToObject, SlotsType } from 'vue';
+import { ActionSheetEmits, ActionSheetSlots } from '@dxtmisha/constructor/ActionSheet';
+import { ActionSheetProps } from './props';
+export type { ActionSheetProps } from './props';
+export declare const D1ActionSheet: DefineSetupFnComponent<ActionSheetProps, ShortEmitsToObject<ActionSheetEmits>, SlotsType<ActionSheetSlots>>;

package/dist/components/Ui/ActionSheet/props.d.ts

@@ -0,0 +1,21 @@
+import { WindowProps } from '../Window';
+import { BarsProps } from '../Bars';
+import { ActionsProps } from '../Actions';
+import { ActionSheetPropsBasic } from '@dxtmisha/constructor/ActionSheet';
+export declare const propsValues: {
+    padding: string[];
+    width: string[];
+};
+export type PropsToken = {
+    padding?: 'sm' | 'md' | 'lg';
+    paddingByIndent?: boolean;
+    width?: 'sm' | 'md' | 'lg' | 'auto';
+};
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export type ActionSheetProps = ActionSheetPropsBasic<WindowProps, BarsProps, ActionsProps> & PropsToken;
+/**
+ * Default value for property/ Значение по умолчанию для свойства
+ */
+export declare const defaults: object;

package/dist/components/Ui/ActionSheet/wiki.d.ts

@@ -0,0 +1,2 @@
+import { WikiStorybook } from '@dxtmisha/wiki';
+export declare const ActionSheetWikiStorybook: WikiStorybook;

package/dist/components/Ui/Actions/D1Actions.vue.d.ts

@@ -0,0 +1,25 @@
+import { ActionsSlots } from '@dxtmisha/constructor/Actions';
+import { ActionsProps } from './props';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { EventClickValue } from '@dxtmisha/constructor';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<ActionsSlots> & ActionsSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<ActionsProps, {}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    click: (event: MouseEvent, value: EventClickValue) => any;
+    clickLite: (value: EventClickValue) => any;
+}, string, PublicProps, Readonly<ActionsProps> & Readonly<{
+    onClick?: ((event: MouseEvent, value: EventClickValue) => any) | undefined;
+    onClickLite?: ((value: EventClickValue) => any) | undefined;
+}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Ui/Actions/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineSetupFnComponent, ShortEmitsToObject, SlotsType } from 'vue';
+import { ActionsEmits, ActionsSlots } from '@dxtmisha/constructor/Actions';
+import { ActionsProps } from './props';
+export type { ActionsProps } from './props';
+export declare const D1Actions: DefineSetupFnComponent<ActionsProps, ShortEmitsToObject<ActionsEmits>, SlotsType<ActionsSlots>>;

package/dist/components/Ui/Actions/props.d.ts

@@ -0,0 +1,21 @@
+import { ActionsPropsBasic } from '@dxtmisha/constructor/Actions';
+import { ButtonProps } from '../Button';
+export declare const propsValues: {
+    align: string[];
+    flexible: string[];
+    padding: string[];
+};
+export type PropsToken = {
+    align?: 'none' | 'center' | 'left' | 'right' | 'block' | 'auto';
+    flexible?: 'adaptiveSm' | 'adaptiveMd' | 'adaptiveLg' | 'adaptiveXl' | 'adaptive2xl' | 'containerSm' | 'containerMd' | 'containerLg' | 'containerXl' | 'container2xl';
+    padding?: 'sm' | 'md' | 'lg' | 'ySm' | 'yMd' | 'yLg' | 'none';
+    paddingByIndent?: boolean;
+};
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export type ActionsProps = ActionsPropsBasic<ButtonProps> & PropsToken;
+/**
+ * Default value for property/ Значение по умолчанию для свойства
+ */
+export declare const defaults: object;

package/dist/components/Ui/Actions/wiki.d.ts

@@ -0,0 +1,2 @@
+import { WikiStorybook } from '@dxtmisha/wiki';
+export declare const ActionsWikiStorybook: WikiStorybook;

package/dist/components/Ui/Anchor/D1Anchor.vue.d.ts

@@ -0,0 +1,21 @@
+import { AnchorSlots } from '@dxtmisha/constructor/Anchor';
+import { AnchorProps } from './props';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<AnchorSlots> & AnchorSlots;
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<AnchorProps, {
+    go(): void;
+    labelId: string;
+}, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<AnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/Ui/Anchor/index.d.ts

@@ -0,0 +1,5 @@
+import { DefineSetupFnComponent, ShortEmitsToObject, SlotsType } from 'vue';
+import { AnchorEmits, AnchorSlots } from '@dxtmisha/constructor/Anchor';
+import { AnchorProps } from './props';
+export type { AnchorProps } from './props';
+export declare const D1Anchor: DefineSetupFnComponent<AnchorProps, ShortEmitsToObject<AnchorEmits>, SlotsType<AnchorSlots>>;

package/dist/components/Ui/Anchor/props.d.ts

@@ -0,0 +1,11 @@
+import { AnchorPropsBasic } from '@dxtmisha/constructor/Anchor';
+export declare const propsValues: {};
+export type PropsToken = {};
+/**
+ * Type describing incoming properties/ Тип, описывающий входящие свойства
+ */
+export type AnchorProps = AnchorPropsBasic & PropsToken;
+/**
+ * Default value for property/ Значение по умолчанию для свойства
+ */
+export declare const defaults: object;