@katlux/toolkit 0.1.0-beta.1 → 0.1.0-beta.2

package/dist/module.d.mts

@@ -1,2 +1,5 @@
-export * from "/home/cagatay/Desktop/projects/KatluxShowcase/packages/katlux-toolkit/src/module";
-export { default } from "/home/cagatay/Desktop/projects/KatluxShowcase/packages/katlux-toolkit/src/module";
+import * as _nuxt_schema from '@nuxt/schema';
+
+declare const _default: _nuxt_schema.NuxtModule<_nuxt_schema.ModuleOptions, _nuxt_schema.ModuleOptions, false>;
+
+export { _default as default };

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@katlux/toolkit",
   "configKey": "katluxToolkit",
-  "version": "0.1.0",
+  "version": "0.1.0-beta.1",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,18 +1,27 @@
-import { createJiti } from "file:///home/cagatay/Desktop/projects/KatluxShowcase/node_modules/jiti/lib/jiti.mjs";
+import { defineNuxtModule, createResolver, addComponentsDir, addImportsDir, addPlugin } from '@nuxt/kit';
 
-const jiti = createJiti(import.meta.url, {
-  "interopDefault": true,
-  "alias": {
-    "@katlux/toolkit": "/home/cagatay/Desktop/projects/KatluxShowcase/packages/katlux-toolkit"
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@katlux/toolkit",
+    configKey: "katluxToolkit"
   },
-  "transformOptions": {
-    "babel": {
-      "plugins": []
-    }
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    addComponentsDir({
+      path: resolve("./runtime/components"),
+      pathPrefix: false,
+      extensions: ["vue"],
+      global: true
+    });
+    addImportsDir(resolve("./runtime/composables"));
+    addPlugin(resolve("./runtime/plugins/registerDirectives"));
+    addPlugin(resolve("./runtime/plugins/PresetPlugin"));
+    nuxt.options.alias["#toolkit"] = resolve("./runtime");
+    nuxt.hook("prepare:types", (options2) => {
+      options2.tsConfig.compilerOptions = options2.tsConfig.compilerOptions || {};
+      options2.tsConfig.compilerOptions.allowArbitraryExtensions = true;
+    });
   }
-})
+});
 
-/** @type {import("/home/cagatay/Desktop/projects/KatluxShowcase/packages/katlux-toolkit/src/module")} */
-const _module = await jiti.import("/home/cagatay/Desktop/projects/KatluxShowcase/packages/katlux-toolkit/src/module.ts");
-
-export default _module?.default ?? _module;
+export { module$1 as default };

package/dist/runtime/app.config.d.ts

@@ -0,0 +1,9 @@
+export { }
+
+declare module '@nuxt/schema' {
+	interface AppConfig {
+		katluxToolkit?: {
+			activePreset?: string
+		}
+	}
+}

package/dist/runtime/components/KAccordion/KAccordion.global.d.vue.ts

@@ -0,0 +1,13 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    multiOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAccordion/KAccordion.global.vue

@@ -0,0 +1,15 @@
+<script setup>
+import { useKAccordionLogic, KAccordionDefaultProps } from "./KAccordion.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KAccordionDefault from "../../presets/default/components/KAccordion/KAccordion.vue";
+const props = defineProps(KAccordionDefaultProps);
+useKAccordionLogic(props);
+const presetComponent = usePresetComponent("KAccordion", KAccordionDefault);
+</script>
+
+<template lang="pug">
+component(:is="presetComponent")
+	template(v-for="(_, slot) in $slots" #[slot]="scope")
+		slot(:name="slot" v-bind="scope")
+</template>

package/dist/runtime/components/KAccordion/KAccordion.global.vue.d.ts

@@ -0,0 +1,13 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    multiOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAccordion/KAccordion.logic.d.ts

@@ -0,0 +1,9 @@
+export interface KAccordionProps {
+    multiOpen?: boolean;
+}
+export declare const KAccordionDefaultProps: {
+    multiOpen: {
+        type: BooleanConstructor;
+    };
+};
+export declare function useKAccordionLogic(props: KAccordionProps): {};

package/dist/runtime/components/KAccordion/KAccordion.logic.js

@@ -0,0 +1,38 @@
+import { ref, provide } from "vue";
+export const KAccordionDefaultProps = {
+  multiOpen: {
+    type: Boolean
+  }
+};
+export function useKAccordionLogic(props) {
+  const openIds = ref([]);
+  const items = ref(/* @__PURE__ */ new Map());
+  function registerItem(id, item) {
+    items.value.set(id, item);
+    return () => {
+      items.value.delete(id);
+    };
+  }
+  function toggleItem(id) {
+    if (props.multiOpen) {
+      if (openIds.value.includes(id)) {
+        openIds.value = openIds.value.filter((i) => i !== id);
+      } else {
+        openIds.value.push(id);
+      }
+    } else {
+      if (openIds.value[0] === id) {
+        openIds.value = [];
+      } else {
+        openIds.value = [id];
+      }
+    }
+  }
+  function isOpen(id) {
+    return openIds.value.includes(id);
+  }
+  provide("accordionRegister", registerItem);
+  provide("accordionToggle", toggleItem);
+  provide("accordionIsOpen", isOpen);
+  return {};
+}

package/dist/runtime/components/KAccordion/KAccordionItem.global.d.vue.ts

@@ -0,0 +1,21 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    isOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAccordion/KAccordionItem.global.vue

@@ -0,0 +1,20 @@
+<script setup>
+import { useKAccordionItemLogic, KAccordionItemDefaultProps } from "./KAccordionItem.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KAccordionItemDefault from "../../presets/default/components/KAccordion/KAccordionItem.vue";
+const props = defineProps(KAccordionItemDefaultProps);
+const { isOpen, toggleAccordion } = useKAccordionItemLogic(props);
+const presetComponent = usePresetComponent("KAccordionItem", KAccordionItemDefault);
+const templateProps = computed(() => ({
+  title: props.title,
+  isOpen: isOpen.value,
+  toggleAccordion
+}));
+</script>
+
+<template lang="pug">
+component(:is="presetComponent" v-bind="templateProps")
+	template(v-for="(_, slot) in $slots" #[slot]="scope")
+		slot(:name="slot" v-bind="scope")
+</template>

package/dist/runtime/components/KAccordion/KAccordionItem.global.vue.d.ts

@@ -0,0 +1,21 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+}>> & Readonly<{}>, {
+    isOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAccordion/KAccordionItem.logic.d.ts

@@ -0,0 +1,17 @@
+export interface KAccordionItemProps {
+    title: string;
+    isOpen?: boolean;
+}
+export declare const KAccordionItemDefaultProps: {
+    title: {
+        type: StringConstructor;
+        required: boolean;
+    };
+    isOpen: {
+        type: BooleanConstructor;
+    };
+};
+export declare function useKAccordionItemLogic(props: KAccordionItemProps): {
+    isOpen: import("vue").ComputedRef<boolean>;
+    toggleAccordion: () => void;
+};

package/dist/runtime/components/KAccordion/KAccordionItem.logic.js

@@ -0,0 +1,59 @@
+import { inject, onMounted, computed, watch, nextTick, onUnmounted } from "vue";
+export const KAccordionItemDefaultProps = {
+  title: {
+    type: String,
+    required: true
+  },
+  isOpen: {
+    type: Boolean
+  }
+};
+export function useKAccordionItemLogic(props) {
+  const register = inject("accordionRegister");
+  const toggle = inject("accordionToggle");
+  const isOpenFn = inject("accordionIsOpen");
+  let unregister = null;
+  onMounted(() => {
+    if (register) {
+      unregister = register(props.title, {});
+      if (props.isOpen && toggle) {
+        nextTick(() => {
+          if (!isOpenFn || !isOpenFn(props.title)) {
+            toggle(props.title);
+          }
+        });
+      }
+    }
+  });
+  onUnmounted(() => {
+    if (unregister) {
+      unregister();
+    }
+  });
+  watch(
+    () => props.isOpen,
+    (shouldBeOpen) => {
+      if (toggle && isOpenFn) {
+        const currentlyOpen = isOpenFn(props.title);
+        if (shouldBeOpen && !currentlyOpen) {
+          toggle(props.title);
+        } else if (!shouldBeOpen && currentlyOpen) {
+          toggle(props.title);
+        }
+      }
+    }
+  );
+  const isOpen = computed(() => {
+    if (!isOpenFn) return !!props.isOpen;
+    return isOpenFn(props.title);
+  });
+  function toggleAccordion() {
+    if (toggle) {
+      toggle(props.title);
+    }
+  }
+  return {
+    isOpen,
+    toggleAccordion
+  };
+}

package/dist/runtime/components/KAlert/KAlert.global.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAlert/KAlert.global.vue

@@ -0,0 +1,9 @@
+<script setup>
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import KAlertDefault from "../../presets/default/components/KAlert/KAlert.vue";
+const presetComponent = usePresetComponent("KAlert", KAlertDefault);
+</script>
+
+<template lang="pug">
+component(:is="presetComponent")
+</template>

package/dist/runtime/components/KAlert/KAlert.global.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KAlert/KAlert.logic.d.ts

@@ -0,0 +1,4 @@
+export interface KAlertProps {
+}
+export declare const KAlertDefaultProps: {};
+export declare function useKAlertLogic(): {};

package/dist/runtime/components/KAlert/KAlert.logic.js

@@ -0,0 +1,4 @@
+export const KAlertDefaultProps = {};
+export function useKAlertLogic() {
+  return {};
+}

package/dist/runtime/components/KBulkActions/KBulkActions.global.d.vue.ts

@@ -0,0 +1,9 @@
+import type { IKDatatableAction, TDataRow } from '@katlux/providers';
+interface Props {
+    bulkActions: IKDatatableAction[];
+    selectedRows: TDataRow[];
+    selectAll: boolean;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KBulkActions/KBulkActions.global.vue

@@ -0,0 +1,32 @@
+<script setup>
+import { useKBulkActionsLogic, KBulkActionsDefaultProps } from "./KBulkActions.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KBulkActionsDefault from "../../presets/default/components/KBulkActions/KBulkActions.vue";
+const props = defineProps({
+  bulkActions: { type: Array, required: true },
+  selectedRows: { type: Array, required: true },
+  selectAll: { type: Boolean, required: true }
+});
+const { selected, dp, doAction } = useKBulkActionsLogic(props);
+const presetComponent = usePresetComponent("KBulkActions", KBulkActionsDefault);
+const templateProps = computed(() => ({
+  bulkActions: props.bulkActions,
+  selectedRows: props.selectedRows,
+  selectAll: props.selectAll,
+  selected: selected.value,
+  dp,
+  doAction
+}));
+const updateSelected = (val) => {
+  selected.value = val;
+};
+</script>
+
+<template lang="pug">
+component(
+	:is="presetComponent" 
+	v-bind="templateProps"
+	@update:selected="updateSelected"
+)
+</template>

package/dist/runtime/components/KBulkActions/KBulkActions.global.vue.d.ts

@@ -0,0 +1,9 @@
+import type { IKDatatableAction, TDataRow } from '@katlux/providers';
+interface Props {
+    bulkActions: IKDatatableAction[];
+    selectedRows: TDataRow[];
+    selectAll: boolean;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KBulkActions/KBulkActions.logic.d.ts

@@ -0,0 +1,19 @@
+import type { IKDatatableAction, TDataRow } from '@katlux/providers';
+import { CFlatClientDataProvider } from '@katlux/providers';
+export interface KBulkActionsProps {
+    bulkActions: IKDatatableAction[];
+    selectedRows: TDataRow[];
+    selectAll: boolean;
+}
+export declare const KBulkActionsDefaultProps: {};
+export declare function useKBulkActionsLogic(props: KBulkActionsProps): {
+    selected: import("vue").Ref<{
+        action: Function;
+        label: string;
+    } | null, IKDatatableAction | {
+        action: Function;
+        label: string;
+    } | null>;
+    dp: CFlatClientDataProvider;
+    doAction: (action: any) => void;
+};

package/dist/runtime/components/KBulkActions/KBulkActions.logic.js

@@ -0,0 +1,24 @@
+import { ref, watch } from "vue";
+import { CFlatClientDataProvider } from "@katlux/providers";
+export const KBulkActionsDefaultProps = {};
+export function useKBulkActionsLogic(props) {
+  const selected = ref(null);
+  const dp = new CFlatClientDataProvider();
+  watch(() => props.bulkActions, (actions) => {
+    dp.setData(actions.map((row) => ({
+      label: row.label,
+      action: row.action
+    })));
+  }, { immediate: true });
+  function doAction(action) {
+    const act = action;
+    if (act && act.action) {
+      act.action(props.selectedRows, props.selectAll);
+    }
+  }
+  return {
+    selected,
+    dp,
+    doAction
+  };
+}

package/dist/runtime/components/KButton/KButton.global.d.vue.ts

@@ -0,0 +1,56 @@
+import { type KButtonProps } from './KButton.logic.js';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    type: {
+        type: import("vue").PropType<KButtonProps["type"]>;
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<KButtonProps["size"]>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: import("vue").PropType<KButtonProps["type"]>;
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<KButtonProps["size"]>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    size: "large" | "medium" | "small" | undefined;
+    type: "info" | "default" | "primary" | "danger" | "success" | "warning" | "light" | "dark" | undefined;
+    disabled: boolean;
+    href: string;
+    loading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KButton/KButton.global.vue

@@ -0,0 +1,24 @@
+<script setup>
+import { useKButtonLogic, KButtonDefaultProps } from "./KButton.logic";
+import { usePresetComponent } from "../../composables/usePresetComponent";
+import { computed } from "vue";
+import KButtonDefault from "../../presets/default/components/KButton/KButton.vue";
+const props = defineProps(KButtonDefaultProps);
+const emit = defineEmits(["click"]);
+const { isLink, isDisabled, buttonClasses, onClick } = useKButtonLogic(props, emit);
+const presetComponent = usePresetComponent("KButton", KButtonDefault);
+const templateProps = computed(() => ({
+  isLink: isLink.value,
+  isDisabled: isDisabled.value,
+  buttonClasses: buttonClasses.value,
+  onClick,
+  href: props.href,
+  loading: props.loading
+}));
+</script>
+
+<template lang="pug">
+component(:is="presetComponent" v-bind="templateProps")
+	template(v-for="(_, slot) in $slots" #[slot]="scope")
+		slot(:name="slot" v-bind="scope")
+</template>

package/dist/runtime/components/KButton/KButton.global.vue.d.ts

@@ -0,0 +1,56 @@
+import { type KButtonProps } from './KButton.logic.js';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    type: {
+        type: import("vue").PropType<KButtonProps["type"]>;
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<KButtonProps["size"]>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    type: {
+        type: import("vue").PropType<KButtonProps["type"]>;
+        default: string;
+    };
+    size: {
+        type: import("vue").PropType<KButtonProps["size"]>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    onClick?: (() => any) | undefined;
+}>, {
+    size: "large" | "medium" | "small" | undefined;
+    type: "info" | "default" | "primary" | "danger" | "success" | "warning" | "light" | "dark" | undefined;
+    disabled: boolean;
+    href: string;
+    loading: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/KButton/KButton.logic.d.ts

@@ -0,0 +1,54 @@
+import { type PropType } from 'vue';
+export interface KButtonProps {
+    type?: 'default' | 'primary' | 'danger' | 'success' | 'warning' | 'info' | 'light' | 'dark';
+    size?: 'large' | 'medium' | 'small';
+    disabled?: boolean;
+    loading?: boolean;
+    href?: string;
+}
+export interface KButtonEmits {
+    (e: 'click'): void;
+}
+/**
+ * KButton Logic Composable
+ *
+ * This composable contains all the business logic for the KButton component,
+ * separated from the presentation layer to enable template customization.
+ *
+ * @param props - Component props
+ * @param emit - Component emits
+ * @returns Button logic and state
+ */
+export declare function useKButtonLogic(props: KButtonProps, emit: KButtonEmits): {
+    isLink: import("vue").ComputedRef<boolean>;
+    isDisabled: import("vue").ComputedRef<boolean | undefined>;
+    buttonClasses: import("vue").ComputedRef<("info" | "default" | "primary" | "danger" | "success" | "warning" | "light" | "dark" | "large" | "medium" | "small" | {
+        disabled: boolean | undefined;
+    })[]>;
+    onClick: () => void;
+};
+/**
+ * Default props for KButton
+ */
+export declare const KButtonDefaultProps: {
+    type: {
+        type: PropType<KButtonProps["type"]>;
+        default: string;
+    };
+    size: {
+        type: PropType<KButtonProps["size"]>;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    href: {
+        type: StringConstructor;
+        default: undefined;
+    };
+};