pxd 0.0.64 → 0.1.3

package/dist/components/search-input/index.d.vue.ts

@@ -0,0 +1,152 @@
+import type { SearchInputProps } from './types';
+declare var __VLS_15: {}, __VLS_23: {};
+type __VLS_Slots = {} & {
+    prefix?: (props: typeof __VLS_15) => any;
+} & {
+    suffix?: (props: typeof __VLS_23) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SearchInputProps, {
+    $: import("vue").ComponentInternalInstance;
+    $data: {};
+    $props: {
+        readonly size?: import("../../types/shared/props.js").ComponentSizeWithXs | undefined;
+        readonly error?: boolean | string | undefined;
+        readonly min?: number | string | undefined;
+        readonly max?: number | string | undefined;
+        readonly align?: "left" | "center" | "right" | undefined;
+        readonly readonly?: boolean | undefined;
+        readonly disabled?: boolean | undefined;
+        readonly password?: boolean | undefined;
+        readonly autofocus?: boolean | undefined;
+        readonly inputType?: string | undefined;
+        readonly inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined;
+        readonly minLength?: number | string | undefined;
+        readonly maxLength?: number | string | undefined;
+        readonly trimOverflow?: boolean | undefined;
+        readonly clearable?: boolean | undefined;
+        readonly clearValue?: any;
+        readonly modelValue?: any;
+        readonly placeholder?: string | undefined;
+        readonly prefixClass?: import("../../types/shared/props.js").ComponentClass | undefined;
+        readonly suffixClass?: import("../../types/shared/props.js").ComponentClass | undefined;
+        readonly selectOnFocus?: boolean | undefined;
+        readonly showWordLimit?: boolean | undefined;
+        readonly wordLimitPosition?: "inside" | "outside" | undefined;
+        readonly clearOnPressEscape?: boolean | undefined;
+        readonly defaultPrefixStyle?: boolean | undefined;
+        readonly defaultSuffixStyle?: boolean | undefined;
+        readonly onChange?: ((args_0: string, args_1: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+        readonly onClick?: ((args_0: MouseEvent) => any) | undefined;
+        readonly onBlur?: ((args_0: FocusEvent) => any) | undefined;
+        readonly onCompositionend?: ((args_0: CompositionEvent) => any) | undefined;
+        readonly onCompositionstart?: ((args_0: CompositionEvent) => any) | undefined;
+        readonly onCompositionupdate?: ((args_0: CompositionEvent) => any) | undefined;
+        readonly onFocus?: ((args_0: FocusEvent) => any) | undefined;
+        readonly onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+    $attrs: import("vue").Attrs;
+    $refs: {
+        [x: string]: unknown;
+    };
+    $slots: Readonly<{
+        [name: string]: import("vue").Slot<any> | undefined;
+    }>;
+    $root: import("vue").ComponentPublicInstance | null;
+    $parent: import("vue").ComponentPublicInstance | null;
+    $host: Element | null;
+    $emit: ((event: "change", args_0: string, args_1: Event) => void) & ((event: "update:modelValue", args_0: string) => void) & ((event: "click", args_0: MouseEvent) => void) & ((event: "blur", args_0: FocusEvent) => void) & ((event: "compositionend", args_0: CompositionEvent) => void) & ((event: "compositionstart", args_0: CompositionEvent) => void) & ((event: "compositionupdate", args_0: CompositionEvent) => void) & ((event: "focus", args_0: FocusEvent) => void) & ((event: "keydown", args_0: KeyboardEvent) => void);
+    $el: any;
+    $options: import("vue").ComponentOptionsBase<Readonly<import("../input/types.js").InputProps> & Readonly<{
+        onChange?: ((args_0: string, args_1: Event) => any) | undefined;
+        "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+        onClick?: ((args_0: MouseEvent) => any) | undefined;
+        onBlur?: ((args_0: FocusEvent) => any) | undefined;
+        onCompositionend?: ((args_0: CompositionEvent) => any) | undefined;
+        onCompositionstart?: ((args_0: CompositionEvent) => any) | undefined;
+        onCompositionupdate?: ((args_0: CompositionEvent) => any) | undefined;
+        onFocus?: ((args_0: FocusEvent) => any) | undefined;
+        onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+    }>, {
+        blur: () => void;
+        clear: (ev: Event) => void;
+        focus: () => void;
+        select: () => void;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        change: (args_0: string, args_1: Event) => any;
+        "update:modelValue": (args_0: string) => any;
+        click: (args_0: MouseEvent) => any;
+        blur: (args_0: FocusEvent) => any;
+        compositionend: (args_0: CompositionEvent) => any;
+        compositionstart: (args_0: CompositionEvent) => any;
+        compositionupdate: (args_0: CompositionEvent) => any;
+        focus: (args_0: FocusEvent) => any;
+        keydown: (args_0: KeyboardEvent) => any;
+    }, string, {
+        align: "center" | "left" | "right";
+        trimOverflow: boolean;
+        wordLimitPosition: "inside" | "outside";
+        clearOnPressEscape: boolean;
+        defaultPrefixStyle: boolean;
+        defaultSuffixStyle: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & {
+        beforeCreate?: (() => void) | (() => void)[];
+        created?: (() => void) | (() => void)[];
+        beforeMount?: (() => void) | (() => void)[];
+        mounted?: (() => void) | (() => void)[];
+        beforeUpdate?: (() => void) | (() => void)[];
+        updated?: (() => void) | (() => void)[];
+        activated?: (() => void) | (() => void)[];
+        deactivated?: (() => void) | (() => void)[];
+        beforeDestroy?: (() => void) | (() => void)[];
+        beforeUnmount?: (() => void) | (() => void)[];
+        destroyed?: (() => void) | (() => void)[];
+        unmounted?: (() => void) | (() => void)[];
+        renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+        errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+    };
+    $forceUpdate: () => void;
+    $nextTick: typeof import("vue").nextTick;
+    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R, import("@vue/reactivity").OnCleanup]) => any : (...args: [any, any, import("@vue/reactivity").OnCleanup]) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+} & Readonly<{
+    align: "center" | "left" | "right";
+    trimOverflow: boolean;
+    wordLimitPosition: "inside" | "outside";
+    clearOnPressEscape: boolean;
+    defaultPrefixStyle: boolean;
+    defaultSuffixStyle: boolean;
+}> & Omit<Readonly<import("../input/types.js").InputProps> & Readonly<{
+    onChange?: ((args_0: string, args_1: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((args_0: string) => any) | undefined;
+    onClick?: ((args_0: MouseEvent) => any) | undefined;
+    onBlur?: ((args_0: FocusEvent) => any) | undefined;
+    onCompositionend?: ((args_0: CompositionEvent) => any) | undefined;
+    onCompositionstart?: ((args_0: CompositionEvent) => any) | undefined;
+    onCompositionupdate?: ((args_0: CompositionEvent) => any) | undefined;
+    onFocus?: ((args_0: FocusEvent) => any) | undefined;
+    onKeydown?: ((args_0: KeyboardEvent) => any) | undefined;
+}>, "select" | "clear" | "blur" | "focus" | ("align" | "trimOverflow" | "wordLimitPosition" | "clearOnPressEscape" | "defaultPrefixStyle" | "defaultSuffixStyle")> & {
+    blur: () => void;
+    clear: (ev: Event) => void;
+    focus: () => void;
+    select: () => void;
+} & {} & import("vue").ComponentCustomProperties & {} & {
+    $slots: {
+        prefix?: (props: {}) => any;
+    } & {
+        suffix?: (props: {}) => any;
+    };
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    search: (args_0: string) => any;
+}, string, import("vue").PublicProps, Readonly<SearchInputProps> & Readonly<{
+    onSearch?: ((args_0: string) => any) | 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/components/search-input/index.vue

@@ -0,0 +1,56 @@
+<script setup>
+import LoaderCircleIcon from "@gdsicon/vue/loader-circle";
+import MagnifyingGlassIcon from "@gdsicon/vue/magnifying-glass";
+import { shallowRef } from "vue";
+import { useForwardRefExpose } from "../../composables/_internal/use-forward-ref-expose.js";
+import { isCompositionKeydown } from "../../utils/event.js";
+import PInput from "../input/index.vue";
+defineOptions({
+	name: "PSearchInput",
+	inheritAttrs: false,
+	model: {
+		prop: "modelValue",
+		event: "update:modelValue"
+	}
+});
+const props = defineProps({ loading: {
+	type: Boolean,
+	required: false
+} });
+const emits = defineEmits(["search"]);
+const inputRef = shallowRef();
+function onKeydown(event) {
+	if (event.key !== "Enter" || props.loading || isCompositionKeydown(event)) {
+		return;
+	}
+	const value = event.target.value;
+	if (!value) {
+		return;
+	}
+	emits("search", value);
+}
+defineExpose(useForwardRefExpose(inputRef));
+</script>
+
+<template>
+  <PInput
+    data-search-input
+    ref="inputRef"
+    :default-prefix-style="false"
+    v-bind="$attrs"
+    @keydown="onKeydown"
+  >
+    <template #prefix>
+      <div class="pxd-search-input--prefix-icon ps-3">
+        <LoaderCircleIcon v-if="loading" class="size-4 motion-safe:animate-spin" />
+        <slot v-else name="prefix">
+          <MagnifyingGlassIcon class="size-4" />
+        </slot>
+      </div>
+    </template>
+
+    <template v-if="$slots.suffix" #suffix>
+      <slot name="suffix" />
+    </template>
+  </PInput>
+</template>

package/dist/components/search-input/types.d.ts

@@ -0,0 +1,7 @@
+export interface SearchInputProps {
+  loading?: boolean
+}
+
+export interface SearchInputEmits {
+  search: [string]
+}

package/dist/components/select/index.d.vue.ts

@@ -0,0 +1,36 @@
+import type { ListModelValue } from '../list/types';
+import type { SelectProps } from './types';
+declare var __VLS_16: {}, __VLS_18: {
+    label: string;
+}, __VLS_36: {
+    item: import("../list/types").ListOption;
+    index: number;
+    group: import("../list/types").ListOptionGroup | undefined;
+    groupIndex: number | undefined;
+}, __VLS_39: {};
+type __VLS_Slots = {} & {
+    prefix?: (props: typeof __VLS_16) => any;
+} & {
+    default?: (props: typeof __VLS_18) => any;
+} & {
+    item?: (props: typeof __VLS_36) => any;
+} & {
+    empty?: (props: typeof __VLS_39) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<SelectProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    change: (args_0: ListModelValue) => any;
+    "update:modelValue": (args_0: ListModelValue) => any;
+}, string, import("vue").PublicProps, Readonly<SelectProps> & Readonly<{
+    onChange?: ((args_0: ListModelValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((args_0: ListModelValue) => any) | undefined;
+}>, {
+    suffixIcon: boolean;
+}, {}, {}, {}, 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/components/select/index.vue

@@ -0,0 +1,257 @@
+<script setup>
+import ChevronDownIcon from "@gdsicon/vue/chevron-down";
+import { computed, nextTick, shallowRef, watch } from "vue";
+import { useListFilter } from "../../composables/_internal/use-list-filter.js";
+import { useListKeyboardController } from "../../composables/_internal/use-list-keyboard-controller.js";
+import { useListSelection } from "../../composables/_internal/use-list-selection.js";
+import { usePopoverResponsive } from "../../composables/_internal/use-popover-responsive.js";
+import { useSelectedListItems } from "../../composables/_internal/use-selected-list-item.js";
+import { useConfigProvider } from "../../contexts/config-provider.js";
+import { getUniqueId } from "../../utils/helper.js";
+import { isNil } from "../../utils/is.js";
+import PButton from "../button/index.vue";
+import PList from "../list/index.vue";
+import PPopover from "../popover/index.vue";
+defineOptions({
+	name: "PSelect",
+	inheritAttrs: false,
+	model: {
+		prop: "modelValue",
+		event: "update:modelValue"
+	}
+});
+const props = defineProps({
+	size: {
+		type: String,
+		required: false
+	},
+	shape: {
+		type: String,
+		required: false
+	},
+	variant: {
+		type: String,
+		required: false
+	},
+	options: {
+		type: Array,
+		required: false
+	},
+	virtual: {
+		type: Boolean,
+		required: false
+	},
+	disabled: {
+		type: Boolean,
+		required: false
+	},
+	multiple: {
+		type: Boolean,
+		required: false
+	},
+	modelValue: {
+		type: [
+			String,
+			Number,
+			Array,
+			null
+		],
+		required: false
+	},
+	suffixIcon: {
+		type: Boolean,
+		required: false,
+		default: true
+	},
+	placeholder: {
+		type: String,
+		required: false
+	},
+	filterable: {
+		type: Boolean,
+		required: false
+	},
+	filterPlaceholder: {
+		type: String,
+		required: false
+	},
+	labelFormat: {
+		type: Function,
+		required: false
+	},
+	closeOnPressEscape: {
+		type: Boolean,
+		required: false
+	}
+});
+const emits = defineEmits(["change", "update:modelValue"]);
+const listId = getUniqueId("select-list");
+const searchInputId = getUniqueId("select-search");
+const FILTERABLE_KEYMAP = {
+	ArrowDown: "next",
+	ArrowUp: "previous",
+	Enter: "activate",
+	Home: "first",
+	End: "last"
+};
+const DEFAULT_KEYMAP = {
+	...FILTERABLE_KEYMAP,
+	" ": "activate"
+};
+const popoverVisible = shallowRef(false);
+const listRef = shallowRef();
+const searchInputRef = shallowRef();
+const filterKeyword = shallowRef("");
+// Resolved from the full options so a selected item that the filter drops still has a label.
+const selectedItems = useSelectedListItems(() => props.options || [], () => props.modelValue);
+const translatedLabel = computed(() => {
+	if (props.labelFormat) {
+		return props.labelFormat(selectedItems.value);
+	}
+	return selectedItems.value.map((item) => item.label).join(", ");
+});
+const configProvider = useConfigProvider();
+const computedSize = computed(() => props.size || configProvider.size);
+const { isAdaptive, responsiveClasses } = usePopoverResponsive();
+// Single mode commits on pick and closes; multiple mode stays open and commits `change`
+// once when the popover closes, so a round of toggles is one event.
+const { selected, apply, reset, commit } = useListSelection(props, emits);
+const { onKeydown } = useListKeyboardController({
+	enabled: () => popoverVisible.value,
+	onCommand: (command) => listRef.value?.dispatch(command) ?? false,
+	keymap: () => props.filterable ? FILTERABLE_KEYMAP : DEFAULT_KEYMAP
+});
+const { filteredOptions } = useListFilter(() => props.options ?? [], filterKeyword);
+const listOptions = computed(() => props.filterable ? filteredOptions.value : props.options ?? []);
+function onSearchInput(ev) {
+	filterKeyword.value = ev.target.value;
+}
+function onListUpdate(next) {
+	if (isNil(next)) {
+		return;
+	}
+	if (apply(next)) {
+		popoverVisible.value = false;
+	}
+}
+watch(popoverVisible, async (visible) => {
+	if (!visible) {
+		filterKeyword.value = "";
+		commit();
+		return;
+	}
+	reset();
+	await nextTick();
+	if (props.filterable) {
+		searchInputRef.value?.focus({ preventScroll: true });
+		return;
+	}
+	listRef.value?.focus();
+});
+watch(listOptions, async () => {
+	await nextTick();
+	listRef.value?.setFirstAsActive();
+});
+</script>
+
+<template>
+  <PPopover
+    data-select
+    v-model="popoverVisible"
+    class="pxd-select"
+    trigger="click"
+    position="bottom"
+    :auto-focus-element="filterable"
+    :disabled="disabled"
+    :adaptive="isAdaptive"
+    :wrapper-class="responsiveClasses.wrapper"
+    :content-class="responsiveClasses.content"
+    :lock-scroll-on-visible="isAdaptive"
+    :close-on-press-escape="closeOnPressEscape"
+    v-bind="$attrs"
+    @wrapper-keydown="onKeydown"
+  >
+    <PButton
+      class="px-1.5 justify-between"
+      align="left"
+      full-width
+      :class="{ 'text-gray-600': !translatedLabel }"
+      :variant="variant"
+      :shape="shape"
+      :size="computedSize"
+      :disabled="disabled"
+    >
+      <template v-if="$slots.prefix" #prefix>
+        <slot name="prefix" />
+      </template>
+
+      <template v-if="translatedLabel">
+        <slot :label="translatedLabel">{{ translatedLabel }}</slot>
+      </template>
+      <template v-else>
+        {{ placeholder }}
+      </template>
+
+      <template v-if="suffixIcon" #suffix>
+        <ChevronDownIcon
+          class="text-sm me-1.5 text-foreground-secondary motion-safe:transition-transform"
+          :class="{ 'rotate-180': popoverVisible }"
+        />
+      </template>
+    </PButton>
+
+    <template #content>
+      <label
+        v-if="filterable"
+        :for="searchInputId"
+        class="px-3 py-2 flex items-center border-b bg-background-100"
+      >
+        <input
+          :id="searchInputId"
+          ref="searchInputRef"
+          :value="filterKeyword"
+          type="text"
+          role="combobox"
+          autocomplete="off"
+          autocorrect="off"
+          spellcheck="false"
+          aria-autocomplete="list"
+          inputmode="search"
+          :aria-controls="listId"
+          :aria-expanded="popoverVisible"
+          :aria-disabled="disabled"
+          :placeholder="filterPlaceholder"
+          class="pxd-select--search h-7 min-w-0 text-sm flex-1 appearance-none border-none bg-transparent font-inherit text-foreground outline-none"
+          @input="onSearchInput"
+          @keydown="onKeydown"
+        />
+      </label>
+
+      <PList
+        :id="listId"
+        ref="listRef"
+        :model-value="selected"
+        :options="listOptions"
+        :multiple="multiple"
+        :virtual="virtual"
+        :loop="!filterable"
+        :default-active-index="filterable ? 0 : -1"
+        class="max-h-68 min-h-0 flex-1"
+        @update:model-value="onListUpdate"
+      >
+        <template v-if="$slots.item" #item="itemSlotProps">
+          <slot name="item" v-bind="itemSlotProps" />
+        </template>
+
+        <template #empty>
+          <slot name="empty">
+            <template v-if="filterKeyword">
+              {{ configProvider.locale.results.searchText }}
+              <span class="whitespace-pre text-foreground">"{{ filterKeyword }}"</span>
+            </template>
+          </slot>
+        </template>
+      </PList>
+    </template>
+  </PPopover>
+</template>

package/dist/components/select/types.d.ts

@@ -0,0 +1,25 @@
+import type { ComponentSize, ComponentShape } from '../../types/shared/props'
+import type { ButtonVariant } from '../button/types'
+import type { ListModelValue, ListOption, ListOptions } from '../list/types'
+
+export interface SelectProps {
+  size?: ComponentSize
+  shape?: ComponentShape
+  variant?: ButtonVariant
+  options?: ListOptions
+  virtual?: boolean
+  disabled?: boolean
+  multiple?: boolean
+  modelValue?: ListModelValue
+  suffixIcon?: boolean
+  placeholder?: string
+  filterable?: boolean
+  filterPlaceholder?: string
+  labelFormat?: (items: ListOptions) => string
+  closeOnPressEscape?: boolean
+}
+
+export interface SelectEmits {
+  change: [ListModelValue]
+  'update:modelValue': [ListModelValue]
+}

package/dist/components/separator/index.d.vue.ts

@@ -1,6 +1,6 @@
 import type { SeparatorProps } from './types';
 declare const __VLS_export: import("vue").DefineComponent<SeparatorProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SeparatorProps> & Readonly<{}>, {
-    direction: import("../../types/shared").ComponentDirection;
+    direction: import("../../types/shared/props").ComponentDirection;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/components/separator/index.vue

@@ -1,18 +1,21 @@
 <script setup>
 defineOptions({
-  name: "PSeparator",
-  inheritAttrs: false
-});
-const props = defineProps({
-  direction: { type: String, required: false, default: "vertical" }
+	name: "PSeparator",
+	inheritAttrs: false
 });
+const props = defineProps({ direction: {
+	type: String,
+	required: false,
+	default: "vertical"
+} });
 </script>
 
 <template>
   <div
+    data-separator
     role="separator"
     :aria-orientation="direction"
-    class="pxd-separator aria-[orientation=vertical]:h-3 inline-block bg-gray-300 leading-inherit aria-[orientation=horizontal]:h-px aria-[orientation=horizontal]:w-full aria-[orientation=vertical]:w-px"
+    class="pxd-separator aria-[orientation=vertical]:h-3 box-border inline-block shrink-0 border-0 border-gray-300 leading-inherit aria-[orientation=horizontal]:w-full aria-[orientation=horizontal]:border-t aria-[orientation=vertical]:border-l aria-[orientation=vertical]:border-gray-500"
     v-bind="$attrs"
   />
 </template>

package/dist/components/separator/types.d.ts

@@ -1,4 +1,4 @@
-import type { ComponentDirection } from '../../types/shared'
+import type { ComponentDirection } from '../../types/shared/props'
 
 export interface SeparatorProps {
   direction?: ComponentDirection

package/dist/components/shimmer-text/index.d.vue.ts

@@ -0,0 +1,18 @@
+import type { ShimmerGradientStop, ShimmerTextProps } from './types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<ShimmerTextProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ShimmerTextProps> & Readonly<{}>, {
+    color: string | ShimmerGradientStop[];
+    disabled: boolean;
+    durations: number;
+}, {}, {}, {}, 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;
+    };
+};