dts.spec.ts.snap

// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html

exports[`vue-tsc-dts > Input: class-slots/component.vue, Output: class-slots/component.vue.d.ts 1`] = `
"import { VNode } from 'vue';
declare const _default: new () => {
    $slots: {
        default(_: {
            num: number;
        }): VNode[];
        foo(_: {
            str: string;
        }): VNode[];
    };
};
export default _default;
"
`;

exports[`vue-tsc-dts > Input: empty-component/component.vue, Output: empty-component/component.vue.d.ts 1`] = `
"declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
export default _default;
"
`;

exports[`vue-tsc-dts > Input: generic/component.vue, Output: generic/component.vue.d.ts 1`] = `
"declare const _default: <T>(__VLS_props: {
    onBar?: (data: number) => any;
    foo: number;
} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
    attrs: any;
    emit: (e: 'bar', data: number) => void;
    slots: Readonly<{
        default?(data: {
            foo: number;
        }): any;
    }> & {
        default?(data: {
            foo: number;
        }): any;
    };
}, __VLS_expose?: (exposed: import("vue").ShallowUnwrapRef<{
    baz: number;
}>) => void, __VLS_setup?: Promise<{
    props: {
        onBar?: (data: number) => any;
        foo: number;
    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
    expose(exposed: import("vue").ShallowUnwrapRef<{
        baz: number;
    }>): void;
    attrs: any;
    slots: Readonly<{
        default?(data: {
            foo: number;
        }): any;
    }> & {
        default?(data: {
            foo: number;
        }): any;
    };
    emit: (e: 'bar', data: number) => void;
}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
    [key: string]: any;
}> & {
    __ctx?: {
        props: {
            onBar?: (data: number) => any;
            foo: number;
        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
        expose(exposed: import("vue").ShallowUnwrapRef<{
            baz: number;
        }>): void;
        attrs: any;
        slots: Readonly<{
            default?(data: {
                foo: number;
            }): any;
        }> & {
            default?(data: {
                foo: number;
            }): any;
        };
        emit: (e: 'bar', data: number) => void;
    };
};
export default _default;
type __VLS_OmitKeepDiscriminatedUnion<T, K extends keyof any> = T extends any ? Pick<T, Exclude<keyof T, K>> : never;
type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
"
`;

exports[`vue-tsc-dts > Input: non-component/component.ts, Output: non-component/component.d.ts 1`] = `
"declare const _default: {};
export default _default;
"
`;

exports[`vue-tsc-dts > Input: options-api/component.ts, Output: options-api/component.d.ts 1`] = `
"interface SubmitPayload {
    /**
     * email of user
     */
    email: string;
    /**
     * password of same user
     */
    password: string;
}
declare const _default: import("vue").DefineComponent<{
    /**
     * Default number
     */
    numberDefault: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * Default function Object
     */
    objectDefault: {
        type: ObjectConstructor;
        default: () => {
            foo: string;
        };
    };
    /**
     * Default function Array
     */
    arrayDefault: {
        type: ArrayConstructor;
        default: () => number[];
    };
    /**
     * Default function more complex
     */
    complexDefault: {
        type: ArrayConstructor;
        default: (props: any) => any[];
    };
}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    submit: ({ email, password }: SubmitPayload) => boolean;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    /**
     * Default number
     */
    numberDefault: {
        type: NumberConstructor;
        default: number;
    };
    /**
     * Default function Object
     */
    objectDefault: {
        type: ObjectConstructor;
        default: () => {
            foo: string;
        };
    };
    /**
     * Default function Array
     */
    arrayDefault: {
        type: ArrayConstructor;
        default: () => number[];
    };
    /**
     * Default function more complex
     */
    complexDefault: {
        type: ArrayConstructor;
        default: (props: any) => any[];
    };
}>> & {
    onSubmit?: (args_0: SubmitPayload) => any;
}, {
    numberDefault: number;
    objectDefault: Record<string, any>;
    arrayDefault: unknown[];
    complexDefault: unknown[];
}, {}>;
export default _default;
"
`;

exports[`vue-tsc-dts > Input: reference-type-events/component.vue, Output: reference-type-events/component.vue.d.ts 1`] = `
"declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
    foo: (data?: {
        foo: string;
    }) => void;
    bar: (value: {
        arg1: number;
        arg2?: any;
    }) => void;
    baz: () => void;
}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>> & {
    onBar?: (value: {
        arg1: number;
        arg2?: any;
    }) => any;
    onFoo?: (data?: {
        foo: string;
    }) => any;
    onBaz?: () => any;
}, {}, {}>;
export default _default;
"
`;

exports[`vue-tsc-dts > Input: reference-type-events/my-events.ts, Output: reference-type-events/my-events.d.ts 1`] = `
"/**
 * Emitted when the foo property is changed.
 */
type MyEventsFoo = 'foo';
export interface MyEvents {
    (event: MyEventsFoo, data?: {
        foo: string;
    }): void;
    (event: 'bar', value: {
        arg1: number;
        arg2?: any;
    }): void;
    (e: 'baz'): void;
}
export {};
"
`;

exports[`vue-tsc-dts > Input: reference-type-exposed/component.vue, Output: reference-type-exposed/component.vue.d.ts 1`] = `
"declare const _default: import("vue").DefineComponent<{}, {
    /**
     * a counter string
     */
    counter: import("vue").Ref<string>;
}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
export default _default;
"
`;

exports[`vue-tsc-dts > Input: reference-type-props/component.vue, Output: reference-type-props/component.vue.d.ts 1`] = `
"import { MyProps } from './my-props';
declare const _default: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<MyProps>, {
    bar: number;
    baz: () => string[];
}>, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<MyProps>, {
    bar: number;
    baz: () => string[];
}>>>, {
    bar: number;
    baz: string[];
}, {}>;
export default _default;
type __VLS_WithDefaults<P, D> = {
    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_Prettify<P[K] & {
        default: D[K];
    }> : P[K];
};
type __VLS_Prettify<T> = {
    [K in keyof T]: T[K];
} & {};
type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
type __VLS_TypePropsToOption<T> = {
    [K in keyof T]-?: {} extends Pick<T, K> ? {
        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
    } : {
        type: import('vue').PropType<T[K]>;
        required: true;
    };
};
"
`;

exports[`vue-tsc-dts > Input: reference-type-props/component-js.vue, Output: reference-type-props/component-js.vue.d.ts 1`] = `
"declare const _default: import("vue").DefineComponent<{
    foo: {
        type: StringConstructor;
        required: true;
    };
    bar: {
        type: StringConstructor;
        default: string;
    };
    baz: {
        type: StringConstructor;
    };
    xfoo: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    xbar: {
        readonly type: StringConstructor;
        readonly value: "";
    };
    xbaz: {
        readonly type: StringConstructor;
    };
}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    foo: {
        type: StringConstructor;
        required: true;
    };
    bar: {
        type: StringConstructor;
        default: string;
    };
    baz: {
        type: StringConstructor;
    };
    xfoo: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    xbar: {
        readonly type: StringConstructor;
        readonly value: "";
    };
    xbaz: {
        readonly type: StringConstructor;
    };
}>>, {
    bar: string;
}, {}>;
export default _default;
"
`;

exports[`vue-tsc-dts > Input: reference-type-props/component-js-setup.vue, Output: reference-type-props/component-js-setup.vue.d.ts 1`] = `
"declare const _default: import("vue").DefineComponent<{
    foo: {
        type: StringConstructor;
        required: true;
    };
    bar: {
        type: StringConstructor;
        default: string;
    };
    baz: {
        type: StringConstructor;
    };
    xfoo: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    xbar: {
        readonly type: StringConstructor;
        readonly value: "";
    };
    xbaz: {
        readonly type: StringConstructor;
    };
    /**
     * The hello property.
     *
     * @since v1.0.0
     */
    hello: {
        type: StringConstructor;
        default: string;
    };
    numberOrStringProp: {
        type: (NumberConstructor | StringConstructor)[];
        default: number;
    };
    arrayProps: {
        type: ArrayConstructor;
        default: () => number[];
    };
}, {}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
    foo: {
        type: StringConstructor;
        required: true;
    };
    bar: {
        type: StringConstructor;
        default: string;
    };
    baz: {
        type: StringConstructor;
    };
    xfoo: {
        readonly type: StringConstructor;
        readonly required: true;
    };
    xbar: {
        readonly type: StringConstructor;
        readonly value: "";
    };
    xbaz: {
        readonly type: StringConstructor;
    };
    /**
     * The hello property.
     *
     * @since v1.0.0
     */
    hello: {
        type: StringConstructor;
        default: string;
    };
    numberOrStringProp: {
        type: (NumberConstructor | StringConstructor)[];
        default: number;
    };
    arrayProps: {
        type: ArrayConstructor;
        default: () => number[];
    };
}>>, {
    bar: string;
    hello: string;
    numberOrStringProp: string | number;
    arrayProps: unknown[];
}, {}>;
export default _default;
"
`;

exports[`vue-tsc-dts > Input: reference-type-props/my-props.ts, Output: reference-type-props/my-props.d.ts 1`] = `
"export interface MyNestedProps {
    /**
     * nested prop documentation
     */
    nestedProp: string;
}
export interface MyIgnoredNestedProps {
    nestedProp: string;
}
export interface MyNestedRecursiveProps {
    recursive: MyNestedRecursiveProps;
}
declare enum MyEnum {
    Small = 0,
    Medium = 1,
    Large = 2
}
declare const categories: readonly ["Uncategorized", "Content", "Interaction", "Display", "Forms", "Addons"];
type MyCategories = typeof categories[number];
export interface MyProps {
    /**
   * string foo
   *
   * @default "rounded"
   * @since v1.0.0
   * @see https://vuejs.org/
   * @example
   * \`\`\`vue
   * <template>
   *   <component foo="straight" />
   * </template>
   * \`\`\`
     */
    foo: string;
    /**
     * optional number bar
     */
    bar?: number;
    /**
     * string array baz
     */
    baz?: string[];
    /**
     * required union type
     */
    union: string | number;
    /**
     * optional union type
     */
    unionOptional?: string | number;
    /**
     * required nested object
     */
    nested: MyNestedProps;
    /**
     * required nested object with intersection
     */
    nestedIntersection: MyNestedProps & {
        /**
         * required additional property
         */
        additionalProp: string;
    };
    /**
     * optional nested object
     */
    nestedOptional?: MyNestedProps | MyIgnoredNestedProps;
    /**
     * required array object
     */
    array: MyNestedProps[];
    /**
     * optional array object
     */
    arrayOptional?: MyNestedProps[];
    /**
     * enum value
     */
    enumValue: MyEnum;
    /**
     * literal type alias that require context
     */
    literalFromContext: MyCategories;
    inlined: {
        foo: string;
    };
    recursive: MyNestedRecursiveProps;
}
export declare const StringRequired: {
    readonly type: StringConstructor;
    readonly required: true;
};
export declare const StringEmpty: {
    readonly type: StringConstructor;
    readonly value: "";
};
export declare const StringUndefined: {
    readonly type: StringConstructor;
};
export {};
"
`;

exports[`vue-tsc-dts > Input: template-slots/component.vue, Output: template-slots/component.vue.d.ts 1`] = `
"declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, {
    "no-bind"?(_: {}): any;
    default?(_: {
        num: number;
    }): any;
    "named-slot"?(_: {
        str: string;
    }): any;
    vbind?(_: {
        num: number;
        str: string;
    }): any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};
"
`;

exports[`vue-tsc-dts > Input: template-slots/component-no-script.vue, Output: template-slots/component-no-script.vue.d.ts 1`] = `
"declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>, {
    "no-bind"?(_: {}): any;
    default?(_: {
        num: number;
    }): any;
    "named-slot"?(_: {
        str: string;
    }): any;
    vbind?(_: {
        num: number;
        str: string;
    }): any;
}>;
export default _default;
type __VLS_WithTemplateSlots<T, S> = T & {
    new (): {
        $slots: S;
    };
};
"
`;

exports[`vue-tsc-dts > Input: ts-component/PropDefinitions.ts, Output: ts-component/PropDefinitions.d.ts 1`] = `
"export interface MyProps {
    /**
     * string foo
     */
    foo: string;
    /**
     * optional number bar
     */
    bar?: number;
}
"
`;

exports[`vue-tsc-dts > Input: ts-component/component.ts, Output: ts-component/component.d.ts 1`] = `undefined`;

exports[`vue-tsc-dts > Input: ts-component/component.tsx, Output: ts-component/component.d.ts 1`] = `undefined`;

exports[`vue-tsc-dts > Input: ts-named-export/component.ts, Output: ts-named-export/component.d.ts 1`] = `
"export declare const Foo: (props: {
    foo: string;
} & {}) => any;
export declare const Bar: (props: {
    bar?: number;
} & {}) => any;
"
`;