@voicenter-team/voicenter-ui-plus 2.0.12 → 3.0.0

package/library/types/components/VcFileUploader/VcFileUploader.vue.d.ts

@@ -0,0 +1,219 @@
+import { ButtonColor, ButtonSize, ButtonType, FileUploaded, ReturnFileType } from '../../types';
+import { IVcBaseInputProps } from '../../composables/input/useInputBase';
+import { IUseInputErrorProps } from '../../composables/input/useInputError';
+import { IUseInputLabelProps } from '../../composables/input/useInputLabel';
+import { TIcon } from '../../types/icons.types';
+interface IFUProps extends IVcBaseInputProps, IUseInputErrorProps, IUseInputLabelProps {
+    /** @description Array of initially uploaded files */
+    files?: Array<FileUploaded>;
+    /** @description Array of currently selected uploaded files */
+    modelValue?: Array<FileUploaded>;
+    /** @description Maximum number of files that can be displayed before showing overflow */
+    maxLength?: number;
+    /** @description Maximum file size limit in bytes for individual files */
+    fileSizeLimit?: number;
+    /** @description Maximum total size limit in bytes for all files combined */
+    fileListSizeLimit?: number;
+    /** @description Accepted file types (mime types or extensions) */
+    accept?: string;
+    /** @description Visual style variant of the upload button */
+    buttonType?: ButtonType;
+    /**
+     * @description Icon shown in the upload button. Accepts a class
+     * string (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide
+     * icon from `@lucide/vue`).
+     */
+    buttonIcon?: TIcon;
+    /** @description Text label for the upload button */
+    buttonText?: string;
+    /** @description Color theme of the upload button */
+    buttonColor?: ButtonColor;
+    /** @description Size variant of the upload button */
+    buttonSize?: ButtonSize;
+    /**
+     * @description Icon shown in the per-file tag. Accepts a class
+     * string (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide
+     * icon from `@lucide/vue`).
+     */
+    tagIcon?: TIcon;
+    /** @description Text to display when no files are selected */
+    noDataText?: string;
+    /** @description Return type for uploaded files (file, base64, dataUrl) */
+    fileType?: ReturnFileType;
+    /** @description Maximum width for file name content in tags */
+    tagMaxContentWidth?: string;
+    /** @description Whether to allow multiple file selection */
+    multiple?: boolean;
+    /** @description Whether to show uploaded file names as tags */
+    showFileName?: boolean;
+    /** @description Whether to hide the clear all files action button */
+    hideClearAction?: boolean;
+}
+declare function onFileChange(): Promise<void>;
+declare function onTagClose(index: number | undefined): void;
+declare function triggerInputClick(): void;
+declare function onClear(): void;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IFUProps>, {
+    disabled: boolean;
+    dataTestName: string;
+    multiple: boolean;
+    showFileName: boolean;
+    hideClearAction: boolean;
+    files: () => never[];
+    modelValue: () => never[];
+    buttonType: string;
+    buttonColor: string;
+    buttonSize: string;
+    buttonIcon: string;
+    buttonText: string;
+    maxLength: number;
+    accept: string;
+    noDataText: string;
+    fileType: string;
+    tagIcon: string;
+    tagMaxContentWidth: string;
+    fileSizeLimit: undefined;
+    fileListSizeLimit: undefined;
+}>>, {
+    clear: typeof onClear;
+    click: typeof triggerInputClick;
+    inputUploader: import("vue").Ref<HTMLInputElement | undefined, HTMLInputElement | undefined>;
+    triggerInputClick: typeof triggerInputClick;
+    onFileChange: typeof onFileChange;
+    onTagClose: typeof onTagClose;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (pl: FileUploaded[]) => void;
+    input: (pl: FileUploaded[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IFUProps>, {
+    disabled: boolean;
+    dataTestName: string;
+    multiple: boolean;
+    showFileName: boolean;
+    hideClearAction: boolean;
+    files: () => never[];
+    modelValue: () => never[];
+    buttonType: string;
+    buttonColor: string;
+    buttonSize: string;
+    buttonIcon: string;
+    buttonText: string;
+    maxLength: number;
+    accept: string;
+    noDataText: string;
+    fileType: string;
+    tagIcon: string;
+    tagMaxContentWidth: string;
+    fileSizeLimit: undefined;
+    fileListSizeLimit: undefined;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((pl: FileUploaded[]) => any) | undefined;
+    onInput?: ((pl: FileUploaded[]) => any) | undefined;
+}>, {
+    maxLength: number;
+    disabled: boolean;
+    modelValue: FileUploaded[];
+    dataTestName: string;
+    buttonType: ButtonType;
+    multiple: boolean;
+    accept: string;
+    noDataText: string;
+    files: FileUploaded[];
+    fileSizeLimit: number;
+    fileListSizeLimit: number;
+    buttonIcon: TIcon;
+    buttonText: string;
+    buttonColor: "" | "primary" | "secondary" | "destructive" | "success" | "warning" | "active" | "primary-alternative";
+    buttonSize: ButtonSize;
+    tagIcon: TIcon;
+    fileType: ReturnFileType;
+    tagMaxContentWidth: string;
+    showFileName: boolean;
+    hideClearAction: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    action?(_: {
+        click: typeof triggerInputClick;
+    }): any;
+    "tag-item"?(_: {
+        data: {
+            id?: number | undefined;
+            File: string | {
+                readonly byteLength: number;
+                slice: (begin: number, end?: number | undefined) => ArrayBuffer;
+                readonly [Symbol.toStringTag]: string;
+            } | {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            } | null;
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+            stream: () => ReadableStream<Uint8Array>;
+            text: () => Promise<string>;
+        };
+        close: typeof onTagClose;
+    }): any;
+    "tag-item-other"?(_: {
+        data: {
+            id?: number | undefined;
+            File: string | {
+                readonly byteLength: number;
+                slice: (begin: number, end?: number | undefined) => ArrayBuffer;
+                readonly [Symbol.toStringTag]: string;
+            } | {
+                readonly lastModified: number;
+                readonly name: string;
+                readonly webkitRelativePath: string;
+                readonly size: number;
+                readonly type: string;
+                arrayBuffer: () => Promise<ArrayBuffer>;
+                slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+                stream: () => ReadableStream<Uint8Array>;
+                text: () => Promise<string>;
+            } | null;
+            readonly lastModified: number;
+            readonly name: string;
+            readonly webkitRelativePath: string;
+            readonly size: number;
+            readonly type: string;
+            arrayBuffer: () => Promise<ArrayBuffer>;
+            slice: (start?: number | undefined, end?: number | undefined, contentType?: string | undefined) => Blob;
+            stream: () => ReadableStream<Uint8Array>;
+            text: () => Promise<string>;
+        };
+        close: typeof onTagClose;
+    }): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};
+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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/library/types/components/VcForm/UiComponents/VcInputLabel.vue.d.ts

@@ -0,0 +1,46 @@
+import { IUseInputLabelProps } from '../../../composables/input/useInputLabel';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IUseInputLabelProps>, {
+    required: boolean;
+    label: string;
+    icon: string;
+    infoText: string;
+    infoTooltipWidth: number;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IUseInputLabelProps>, {
+    required: boolean;
+    label: string;
+    icon: string;
+    infoText: string;
+    infoTooltipWidth: number;
+}>>> & Readonly<{}>, {
+    required: boolean;
+    icon: import("../../..").TIcon;
+    label: string;
+    infoText: string;
+    infoTooltipWidth: string | number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    "info-text"?(_: {}): any;
+    "label-action"?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};
+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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/library/types/components/VcForm/VcForm.vue.d.ts

@@ -0,0 +1,89 @@
+import { FormPromiseType, LabelPositionType } from '../../types';
+import { COMPONENT_SIZE_TYPE } from '../../enum/constants';
+interface IFProps {
+    /** @description Form data model object containing all form field values */
+    model?: object;
+    /** @description Position of form labels relative to inputs (top, left, right) */
+    labelPosition?: LabelPositionType;
+    /** @description Maximum width of the form container */
+    maxWidth?: string | number;
+    /** @description Size variant for all form inputs */
+    size?: COMPONENT_SIZE_TYPE;
+    /** @description Whether all form inputs are disabled */
+    disabled?: boolean;
+    /** @description Whether to scroll to the first error field on validation failure */
+    scrollToError?: boolean;
+    /** @description Whether form items are displayed inline */
+    inline?: boolean;
+    /** @description Whether to display validation messages inline with inputs */
+    inlineMessage?: boolean;
+    /** @description Whether to show status icons for validation states */
+    statusIcon?: boolean;
+}
+declare function validate(): Promise<FormPromiseType>;
+declare function validateField(field: string | string[]): Promise<FormPromiseType>;
+declare function resetFields(fields?: string | string[]): void;
+declare function scrollToField(prop?: string): void;
+declare function clearValidate(props?: string | string[]): void;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IFProps>, {
+    labelPosition: string;
+    maxWidth: string;
+    size: string;
+    disabled: boolean;
+    scrollToError: boolean;
+    inline: undefined;
+    inlineMessage: undefined;
+    statusIcon: undefined;
+    model: undefined;
+}>>, {
+    validate: typeof validate;
+    validateField: typeof validateField;
+    resetFields: typeof resetFields;
+    scrollToField: typeof scrollToField;
+    clearValidate: typeof clearValidate;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IFProps>, {
+    labelPosition: string;
+    maxWidth: string;
+    size: string;
+    disabled: boolean;
+    scrollToError: boolean;
+    inline: undefined;
+    inlineMessage: undefined;
+    statusIcon: undefined;
+    model: undefined;
+}>>> & Readonly<{}>, {
+    size: "" | "small" | "default" | "large";
+    disabled: boolean;
+    maxWidth: string | number;
+    statusIcon: boolean;
+    labelPosition: LabelPositionType;
+    inlineMessage: boolean;
+    model: object;
+    scrollToError: boolean;
+    inline: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};
+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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/library/types/components/VcForm/VcFormItem.vue.d.ts

@@ -0,0 +1,75 @@
+import { FormItemRule, FormValidateCallback, FormValidationResult } from '../../utils/element-plus-imports';
+import { TIcon } from '../../types/icons.types';
+interface IFIProps {
+    required?: boolean;
+    label?: string;
+    /**
+     * @description Icon shown before the label text. Accepts a class
+     * string (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide
+     * icon from `@lucide/vue`).
+     */
+    icon?: TIcon;
+    infoText?: string;
+    infoTooltipWidth?: string | number;
+    rules?: Array<FormItemRule>;
+    prop?: string | Array<string>;
+}
+declare function resetField(): void;
+declare function clearValidate(): void;
+declare function validate(trigger: string, callback?: FormValidateCallback | undefined): FormValidationResult | undefined;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IFIProps>, {
+    required: boolean;
+    label: string;
+    icon: string;
+    infoText: string;
+    infoTooltipWidth: string;
+    rules: () => never[];
+    prop: undefined;
+}>>, {
+    resetField: typeof resetField;
+    clearValidate: typeof clearValidate;
+    validate: typeof validate;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IFIProps>, {
+    required: boolean;
+    label: string;
+    icon: string;
+    infoText: string;
+    infoTooltipWidth: string;
+    rules: () => never[];
+    prop: undefined;
+}>>> & Readonly<{}>, {
+    required: boolean;
+    icon: TIcon;
+    label: string;
+    infoText: string;
+    infoTooltipWidth: string | number;
+    rules: FormItemRule[];
+    prop: string | string[];
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    "label-action"?(_: {}): any;
+    "info-text"?(_: {}): any;
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};
+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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/library/types/components/VcHtmlEditor/VcHtmlEditor.vue.d.ts

@@ -0,0 +1,63 @@
+import type { TMDEditorParameterItem } from '../../types';
+export interface IProps {
+    modelValue?: string;
+    disabled?: boolean;
+    useParameters?: boolean;
+    minHeight?: number | string;
+    maxHeight?: number | string;
+    parameters?: Array<TMDEditorParameterItem>;
+    isTeleported?: boolean;
+    readonly?: boolean;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IProps>, {
+    modelValue: string;
+    disabled: boolean;
+    minHeight: number;
+    maxHeight: undefined;
+    parameters: undefined;
+    useParameters: boolean;
+    isTeleported: undefined;
+    readonly: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (pl: string) => void;
+    change: (pl: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IProps>, {
+    modelValue: string;
+    disabled: boolean;
+    minHeight: number;
+    maxHeight: undefined;
+    parameters: undefined;
+    useParameters: boolean;
+    isTeleported: undefined;
+    readonly: boolean;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((pl: string) => any) | undefined;
+    onChange?: ((pl: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    modelValue: string;
+    maxHeight: string | number;
+    readonly: boolean;
+    isTeleported: boolean;
+    useParameters: boolean;
+    parameters: TMDEditorParameterItem[];
+    minHeight: string | number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};
+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];
+} & {};

package/library/types/components/VcHtmlEditor/VcHtmlEditorToolbar.vue.d.ts

@@ -0,0 +1,43 @@
+import type { TMDEditorParameterItem } from '../../types';
+import { THtmlInsertMenuAction } from './htmlEditor.config';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    isTeleported?: boolean | undefined;
+    readonly?: boolean | undefined;
+    isPreviewMode?: boolean | undefined;
+    useParameters?: boolean | undefined;
+    parameters?: TMDEditorParameterItem[] | undefined;
+    isCopied?: boolean | undefined;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "toggle-preview": () => void;
+    "copy-content": () => void;
+    "wrap-selection": (prefix: string, suffix: string) => void;
+    "insert-link": () => void;
+    "insert-heading": (level: number) => void;
+    "insert-template": (action: THtmlInsertMenuAction) => void;
+    "insert-parameter": (parameter: TMDEditorParameterItem, state?: "opening" | "closing" | undefined) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToRuntimeProps<{
+    isTeleported?: boolean | undefined;
+    readonly?: boolean | undefined;
+    isPreviewMode?: boolean | undefined;
+    useParameters?: boolean | undefined;
+    parameters?: TMDEditorParameterItem[] | undefined;
+    isCopied?: boolean | undefined;
+}>>> & Readonly<{
+    "onToggle-preview"?: (() => any) | undefined;
+    "onCopy-content"?: (() => any) | undefined;
+    "onWrap-selection"?: ((prefix: string, suffix: string) => any) | undefined;
+    "onInsert-link"?: (() => any) | undefined;
+    "onInsert-heading"?: ((level: number) => any) | undefined;
+    "onInsert-template"?: ((action: THtmlInsertMenuAction) => any) | undefined;
+    "onInsert-parameter"?: ((parameter: TMDEditorParameterItem, state?: "opening" | "closing" | undefined) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};

package/library/types/components/VcHtmlEditor/htmlEditor.config.d.ts

@@ -0,0 +1,20 @@
+import type { TMDEditorParameterItem } from '../../types';
+import type { TIcon } from '../../types/icons.types';
+export type THtmlInsertMenuAction = 'image' | 'table' | 'code';
+export declare const htmlHeadingMenuItems: Array<{
+    label: string;
+    icon: TIcon;
+    level: number;
+}>;
+export declare const htmlInsertMenuItems: Array<{
+    label: string;
+    icon: TIcon;
+    key: THtmlInsertMenuAction;
+}>;
+export declare function getHtmlInsertSnippet(action: THtmlInsertMenuAction): "<img src=\"\" alt=\"\" />" | "<table>\n  <thead>\n    <tr>\n      <th>Column 1</th>\n      <th>Column 2</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>Value 1</td>\n      <td>Value 2</td>\n    </tr>\n  </tbody>\n</table>" | "<pre><code></code></pre>";
+export declare function getHtmlInsertAnchorOffset(action: THtmlInsertMenuAction): number | undefined;
+export declare function buildPreviewStyleTag(): string;
+export declare function injectPreviewStyles(html: string): string;
+export declare function replacePreviewParameters(html: string): string;
+export declare function buildHtmlPreviewDocument(htmlSource: string): string;
+export declare function getParameterDisplayLabel(parameter: TMDEditorParameterItem): string;

package/library/types/components/VcHyperLink/VcHyperLink.vue.d.ts

@@ -0,0 +1,72 @@
+import { VcHyperLinkColor, VcHyperLinkType } from '../../types';
+import { TEXT_SIZE_TYPE } from '../../enum/constants';
+import { TIcon } from '../../types/icons.types';
+type SIZE_TYPE = TEXT_SIZE_TYPE;
+interface IHLProps {
+    /**
+     * @description Icon shown before the link text. Accepts a class
+     * string (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide
+     * icon from `@lucide/vue`).
+     */
+    icon?: TIcon;
+    /** @description URL or route path for the hyperlink */
+    href?: string;
+    /** @description Type of link (internal router link or external anchor) */
+    type?: VcHyperLinkType;
+    /** @description Color theme of the hyperlink */
+    color?: VcHyperLinkColor;
+    /** @description Data attribute for testing purposes */
+    dataTestName?: string;
+    /** @description Text size variant for the link */
+    size?: SIZE_TYPE;
+}
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IHLProps>, {
+    icon: string;
+    href: string;
+    type: string;
+    color: string;
+    dataTestName: string;
+    size: string;
+}>>, {
+    attributeName: import("vue").ComputedRef<"to" | "href">;
+    textSize: import("vue").ComputedRef<string>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<IHLProps>, {
+    icon: string;
+    href: string;
+    type: string;
+    color: string;
+    dataTestName: string;
+    size: string;
+}>>> & Readonly<{}>, {
+    size: "" | "xxs" | "xs" | "sm" | "base" | "lg" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl";
+    icon: TIcon;
+    color: "" | "primary" | "secondary" | "destructive" | "success" | "warning" | "active" | "primary-alternative";
+    type: VcHyperLinkType;
+    href: string;
+    dataTestName: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, {
+    default?(_: {}): any;
+}>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToRuntimeProps<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;
+    };
+};
+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_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};