lew-ui 2.7.20 → 2.7.22

package/LICENSE

@@ -1,21 +1,21 @@
-MIT License
-
-Copyright (c) 2023 lew
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+MIT License
+
+Copyright (c) 2023 lew
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/_components/CommonIcon.vue.d.ts

@@ -0,0 +1,77 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    dark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    speed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    dark: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    strokeWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    speed: {
+        type: NumberConstructor;
+        default: number;
+    };
+    fill: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    loading: boolean;
+    fill: string;
+    type: string;
+    color: string;
+    size: number;
+    dark: boolean;
+    strokeWidth: number;
+    speed: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/_components/RenderComponent.vue.d.ts

@@ -0,0 +1,31 @@
+declare const _default: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    renderFn: {
+        type: null;
+        required: true;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    componentProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    renderFn: {
+        type: null;
+        required: true;
+    };
+    type: {
+        type: StringConstructor;
+        default: string;
+    };
+    componentProps: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+}>> & Readonly<{}>, {
+    type: string;
+    componentProps: Record<string, any>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/data/collapse/index.d.ts

@@ -0,0 +1,6 @@
+export * from './src/collapseItemEmits';
+export * from './src/emits';
+export { default as LewCollapse } from './src/LewCollapse.vue';
+export { default as LewCollapseItem } from './src/LewCollapseItem.vue';
+export { default as LewCollapseTransition } from './src/LewCollapseTransition.vue';
+export * from './src/props';

package/dist/components/data/collapse/src/LewCollapse.vue.d.ts

@@ -0,0 +1,44 @@
+import { LewCollapseModelValue } from '../../../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<LewCollapseModelValue>;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (value: LewCollapseModelValue) => void;
+    "update:modelValue": (value: LewCollapseModelValue) => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<LewCollapseModelValue>;
+    };
+}>> & Readonly<{
+    onChange?: ((value: LewCollapseModelValue) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: LewCollapseModelValue) => any) | undefined;
+}>, {
+    width: import("csstype").Property.Width<0 | (string & {})>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+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/data/collapse/src/LewCollapseItem.vue.d.ts

@@ -0,0 +1,68 @@
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        title?(_: {
+            props: {
+                readonly radius: import("csstype").Property.BorderRadius<0 | (string & {})>;
+                readonly title?: string | undefined;
+                readonly collapseKey?: string | undefined;
+            };
+        }): any;
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    collapseKey: {
+        type: StringConstructor;
+        required: boolean;
+        validator: (value: any) => boolean;
+    };
+    title: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    radius: {
+        type: PropType<import("csstype").Property.BorderRadius>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<boolean>;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (expanded: boolean, key: string | number) => void;
+    "update:modelValue": (value: boolean) => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    collapseKey: {
+        type: StringConstructor;
+        required: boolean;
+        validator: (value: any) => boolean;
+    };
+    title: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    radius: {
+        type: PropType<import("csstype").Property.BorderRadius>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    modelValue: {
+        type: globalThis.PropType<boolean>;
+    };
+}>> & Readonly<{
+    onChange?: ((expanded: boolean, key: string | number) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {
+    radius: import("csstype").Property.BorderRadius<0 | (string & {})>;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLDivElement>;
+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/data/collapse/src/LewCollapseTransition.vue.d.ts

@@ -0,0 +1,55 @@
+type DimensionType = 'height' | 'width';
+interface Props {
+    name?: string;
+    dimension?: DimensionType;
+    duration?: number;
+    easing?: string;
+}
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    beforeAppear: (el: Element) => void;
+    appear: (el: Element) => void;
+    afterAppear: (el: Element) => void;
+    appearCancelled: (el: Element) => void;
+    beforeEnter: (el: Element) => void;
+    enter: (el: Element, done: () => void) => void;
+    afterEnter: (el: Element) => void;
+    enterCancelled: (el: Element) => void;
+    beforeLeave: (el: Element) => void;
+    leave: (el: Element, done: () => void) => void;
+    afterLeave: (el: Element) => void;
+    leaveCancelled: (el: Element) => void;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    onBeforeAppear?: ((el: Element) => any) | undefined;
+    onAppear?: ((el: Element) => any) | undefined;
+    onAfterAppear?: ((el: Element) => any) | undefined;
+    onAppearCancelled?: ((el: Element) => any) | undefined;
+    onBeforeEnter?: ((el: Element) => any) | undefined;
+    onEnter?: ((el: Element, done: () => void) => any) | undefined;
+    onAfterEnter?: ((el: Element) => any) | undefined;
+    onEnterCancelled?: ((el: Element) => any) | undefined;
+    onBeforeLeave?: ((el: Element) => any) | undefined;
+    onLeave?: ((el: Element, done: () => void) => any) | undefined;
+    onAfterLeave?: ((el: Element) => any) | undefined;
+    onLeaveCancelled?: ((el: Element) => any) | undefined;
+}>, {
+    name: string;
+    dimension: DimensionType;
+    duration: number;
+    easing: string;
+}, {}, {}, {}, string, import('vue').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/data/collapse/src/collapseItemEmits.d.ts

@@ -0,0 +1,7 @@
+export declare const collapseItemEmits: {
+    readonly change: (expanded: boolean, key: string | number) => {
+        expanded: boolean;
+        key: string | number;
+    };
+};
+export type LewCollapseItemEmits = typeof collapseItemEmits;

package/dist/components/data/collapse/src/collapseTransitionEmits.d.ts

@@ -0,0 +1,15 @@
+export declare const collapseTransitionEmits: {
+    readonly beforeAppear: (el: Element) => Element;
+    readonly appear: (el: Element) => Element;
+    readonly afterAppear: (el: Element) => Element;
+    readonly appearCancelled: (el: Element) => Element;
+    readonly beforeEnter: (el: Element) => Element;
+    readonly enter: (el: Element, done: () => void) => (Element | (() => void))[];
+    readonly afterEnter: (el: Element) => Element;
+    readonly enterCancelled: (el: Element) => Element;
+    readonly beforeLeave: (el: Element) => Element;
+    readonly leave: (el: Element, done: () => void) => (Element | (() => void))[];
+    readonly afterLeave: (el: Element) => Element;
+    readonly leaveCancelled: (el: Element) => Element;
+};
+export type LewCollapseTransitionEmits = typeof collapseTransitionEmits;

package/dist/components/data/collapse/src/emits.d.ts

@@ -0,0 +1,4 @@
+import { LewCollapseModelValue } from '../../../..';
+export declare const collapseEmits: {
+    readonly change: (value: LewCollapseModelValue) => LewCollapseModelValue;
+};

package/dist/components/data/collapse/src/props.d.ts

@@ -0,0 +1,38 @@
+import { Property } from 'csstype';
+import { ExtractPublicPropTypes, PropType } from 'vue';
+export declare const collapseModel: {
+    modelValue: {
+        type: PropType<string[] | string>;
+    };
+};
+export declare const collapseItemModel: {
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare const collapseProps: {
+    width: {
+        type: PropType<Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+};
+export declare const collapseItemProps: {
+    collapseKey: {
+        type: StringConstructor;
+        required: boolean;
+        validator: (value: any) => boolean;
+    };
+    title: {
+        type: StringConstructor;
+        validator: (value: any) => boolean;
+    };
+    radius: {
+        type: PropType<Property.BorderRadius>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+};
+export type LewCollapseProps = ExtractPublicPropTypes<typeof collapseProps>;
+export type LewCollapseItemProps = ExtractPublicPropTypes<typeof collapseItemProps>;

package/dist/components/data/desc/index.d.ts

@@ -0,0 +1,4 @@
+export * from './src/emits';
+export { default as LewDesc } from './src/LewDesc.vue';
+export { default as LewDescItem } from './src/LewDescItem.vue';
+export * from './src/props';

package/dist/components/data/desc/src/LewDesc.vue.d.ts

@@ -0,0 +1,257 @@
+import { LewDescOption } from '../../../../types';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<string, (_: {
+        field: string | undefined;
+        label: string | undefined;
+        dataSource: Record<string, any>;
+        value: string;
+    }) => any>>;
+    refs: {
+        descLabelRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+            size: {
+                type: PropType<import('../../../../types').LewSize>;
+                default: string;
+            };
+            padding: {
+                type: NumberConstructor;
+                default: number;
+            };
+            options: {
+                type: PropType<any>;
+            };
+        }>> & Readonly<{}>, {
+            getWidth: () => number | undefined;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+            size: import('../../../../types').LewSize;
+            padding: number;
+        }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            formLabelRef: HTMLDivElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<globalThis.ExtractPropTypes<{
+            size: {
+                type: PropType<import('../../../../types').LewSize>;
+                default: string;
+            };
+            padding: {
+                type: NumberConstructor;
+                default: number;
+            };
+            options: {
+                type: PropType<any>;
+            };
+        }>> & Readonly<{}>, {
+            getWidth: () => number | undefined;
+        }, {}, {}, {}, {
+            size: import('../../../../types').LewSize;
+            padding: number;
+        }> | null;
+    };
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<LewDescOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+    };
+    dataSource: {
+        type: PropType<Record<string, any>>;
+        required: boolean;
+        default: () => {};
+        validator: (value: unknown) => boolean;
+    };
+    size: {
+        type: PropType<import('../../../../types').LewSize>;
+        default: string;
+        typeValues: import('../../../../types').LewSize[];
+        validator: (value: any) => boolean;
+    };
+    labelX: {
+        type: PropType<import("csstype").Property.TextAlign>;
+        default: string;
+        typeValues: import('../../../../types').LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    valueX: {
+        type: PropType<import("csstype").Property.TextAlign>;
+        default: string;
+        typeValues: import('../../../../types').LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    gap: {
+        type: PropType<import("csstype").Property.Gap>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    columns: {
+        type: PropType<number>;
+        default: number;
+        validator: (value: number | undefined) => boolean;
+    };
+    labelWidth: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    direction: {
+        type: PropType<import('../../../../types').LewDirection>;
+        default: string;
+        typeValues: import('../../../../types').LewDirection[];
+        validator: (value: any) => boolean;
+    };
+    id: {
+        type: StringConstructor;
+        hidden: boolean;
+        validator: (value: any) => boolean;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    ready: () => void;
+}, string, import('vue').PublicProps, Readonly<globalThis.ExtractPropTypes<{
+    options: {
+        type: PropType<LewDescOption[]>;
+        required: boolean;
+        typePopKeys: string[];
+        validator: (value: any[] | undefined) => boolean;
+    };
+    dataSource: {
+        type: PropType<Record<string, any>>;
+        required: boolean;
+        default: () => {};
+        validator: (value: unknown) => boolean;
+    };
+    size: {
+        type: PropType<import('../../../../types').LewSize>;
+        default: string;
+        typeValues: import('../../../../types').LewSize[];
+        validator: (value: any) => boolean;
+    };
+    labelX: {
+        type: PropType<import("csstype").Property.TextAlign>;
+        default: string;
+        typeValues: import('../../../../types').LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    valueX: {
+        type: PropType<import("csstype").Property.TextAlign>;
+        default: string;
+        typeValues: import('../../../../types').LewXAlignment[];
+        validator: (value: any) => boolean;
+    };
+    gap: {
+        type: PropType<import("csstype").Property.Gap>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    width: {
+        type: PropType<import("csstype").Property.Width>;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    columns: {
+        type: PropType<number>;
+        default: number;
+        validator: (value: number | undefined) => boolean;
+    };
+    labelWidth: {
+        type: PropType<import("csstype").Property.Width>;
+        default: string;
+        validator: (value: string | number | undefined) => boolean;
+    };
+    direction: {
+        type: PropType<import('../../../../types').LewDirection>;
+        default: string;
+        typeValues: import('../../../../types').LewDirection[];
+        validator: (value: any) => boolean;
+    };
+    id: {
+        type: StringConstructor;
+        hidden: boolean;
+        validator: (value: any) => boolean;
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+        validator: (value: any) => boolean;
+    };
+}>> & Readonly<{
+    onReady?: (() => any) | undefined;
+}>, {
+    size: import('../../../../types').LewSize;
+    direction: import('../../../../types').LewDirection;
+    columns: number;
+    gap: import("csstype").Property.Gap<0 | (string & {})>;
+    labelWidth: import("csstype").Property.Width<0 | (string & {})>;
+    dataSource: Record<string, any>;
+    labelX: import("csstype").Property.TextAlign;
+    valueX: import("csstype").Property.TextAlign;
+    bordered: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {
+    descLabelRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<globalThis.ExtractPropTypes<{
+        size: {
+            type: PropType<import('../../../../types').LewSize>;
+            default: string;
+        };
+        padding: {
+            type: NumberConstructor;
+            default: number;
+        };
+        options: {
+            type: PropType<any>;
+        };
+    }>> & Readonly<{}>, {
+        getWidth: () => number | undefined;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        size: import('../../../../types').LewSize;
+        padding: number;
+    }, true, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        formLabelRef: HTMLDivElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<globalThis.ExtractPropTypes<{
+        size: {
+            type: PropType<import('../../../../types').LewSize>;
+            default: string;
+        };
+        padding: {
+            type: NumberConstructor;
+            default: number;
+        };
+        options: {
+            type: PropType<any>;
+        };
+    }>> & Readonly<{}>, {
+        getWidth: () => number | undefined;
+    }, {}, {}, {}, {
+        size: import('../../../../types').LewSize;
+        padding: number;
+    }> | null;
+}, HTMLDivElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};