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

package/library/types/components/VcTree/treeTypeUtils.d.ts

@@ -0,0 +1,20 @@
+import type { VcTreeNodeType } from '../../types';
+/**
+ * Helpers for safely narrowing values that come back from `el-tree`'s
+ * intentionally-loose `any` boundary, or from indexing an object by a
+ * dynamic `keyof T` (which under `Record<string, unknown>` returns
+ * `unknown`).
+ *
+ * No type assertions: every narrowing here is a real runtime check or a
+ * type predicate that ESLint's `no-restricted-syntax` rule will allow.
+ */
+export declare function asArray<T>(v: unknown): Array<T>;
+export declare function asTreeKey(v: unknown): string | number;
+/**
+ * Narrows an opaque value back to the generic node type. We pass
+ * `Array<NodeType>` down to `el-tree` and trust it to round-trip the same
+ * objects in its callbacks; el-tree's signature uses `any`, which we don't
+ * — so this predicate bridges the gap. It only guards against null/non-
+ * object inputs at runtime; the shape itself is the consumer's contract.
+ */
+export declare function isTreeNode<NodeType extends VcTreeNodeType>(v: unknown): v is NodeType;

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

@@ -0,0 +1,74 @@
+import { ConfigOptionType, ExtractValueType, OptionMappedType, OptionValueType } from '../../types';
+declare const _default: <Option extends OptionValueType, Config extends ConfigOptionType<Option>, Model extends ExtractValueType<Option, Config>>(__VLS_props: {
+    readonly onChange?: ((option: Option) => any) | undefined;
+    disabled?: boolean | undefined;
+    options?: Option[] | undefined;
+    modelValue?: Model | undefined;
+    readonly "onUpdate:modelValue"?: ((value: Model) => any) | undefined;
+    dataTestName?: string | undefined;
+    config?: Config | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
+    attrs: any;
+    slots: {
+        "tab-item"?(_: {
+            option: OptionMappedType<Option, Config>;
+            isActive: boolean;
+        }): any;
+    };
+    emit: {
+        (event: 'change', option: Option): void;
+        (event: 'update:modelValue', value: Model): void;
+    };
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        readonly onChange?: ((option: Option) => any) | undefined;
+        disabled?: boolean | undefined;
+        options?: Option[] | undefined;
+        modelValue?: Model | undefined;
+        readonly "onUpdate:modelValue"?: ((value: Model) => any) | undefined;
+        dataTestName?: string | undefined;
+        config?: Config | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        "tab-item"?(_: {
+            option: OptionMappedType<Option, Config>;
+            isActive: boolean;
+        }): any;
+    };
+    emit: {
+        (event: 'change', option: Option): void;
+        (event: 'update:modelValue', value: Model): void;
+    };
+}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            readonly onChange?: ((option: Option) => any) | undefined;
+            disabled?: boolean | undefined;
+            options?: Option[] | undefined;
+            modelValue?: Model | undefined;
+            readonly "onUpdate:modelValue"?: ((value: Model) => any) | undefined;
+            dataTestName?: string | undefined;
+            config?: Config | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            "tab-item"?(_: {
+                option: OptionMappedType<Option, Config>;
+                isActive: boolean;
+            }): any;
+        };
+        emit: {
+            (event: 'change', option: Option): void;
+            (event: 'update:modelValue', value: Model): void;
+        };
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/library/types/components/VcWizard/VcSummaryProgress.vue.d.ts

@@ -0,0 +1,54 @@
+import { TIcon } from '../../types/icons.types';
+interface Props {
+    /**
+     * @description Icon shown in the step circle. Accepts a class string
+     * (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide icon from
+     * `@lucide/vue`).
+     */
+    icon?: TIcon;
+    lineFilled?: boolean;
+    visible?: boolean;
+    isActive?: boolean;
+    activeDot?: boolean;
+    hideDetails?: boolean;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    icon: string;
+    lineFilled: boolean;
+    visible: boolean;
+    isActive: boolean;
+    activeDot: boolean;
+    hideDetails: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    icon: string;
+    lineFilled: boolean;
+    visible: boolean;
+    isActive: boolean;
+    activeDot: boolean;
+    hideDetails: boolean;
+}>>> & Readonly<{}>, {
+    icon: TIcon;
+    visible: boolean;
+    isActive: boolean;
+    lineFilled: boolean;
+    activeDot: boolean;
+    hideDetails: boolean;
+}, {}, {}, {}, 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/VcWizard/VcWizard.vue.d.ts

@@ -0,0 +1,107 @@
+import { VcWizardStepType, VcWizardSummaryType } from '../../types';
+interface Props {
+    activeStep?: number | string;
+    steps?: Array<VcWizardStepType>;
+    showHeader?: boolean;
+    showSummary?: boolean;
+    dataLoading?: boolean;
+    summary?: VcWizardSummaryType;
+    height?: string | number;
+    canNext?: boolean;
+    lazy?: boolean;
+    minifySummery?: boolean;
+    autoStepGuards?: boolean;
+}
+declare function resetWizardData(): void;
+declare function onNext(): void;
+declare function onPrev(): void;
+declare function goToStep(index: number): Promise<void>;
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    activeStep: number;
+    steps: () => never[];
+    showHeader: boolean;
+    showSummary: boolean;
+    dataLoading: boolean;
+    summary: () => {};
+    height: string;
+    canNext: boolean;
+    lazy: boolean;
+    minifySummery: boolean;
+    autoStepGuards: boolean;
+}>>, {
+    resetWizardData: typeof resetWizardData;
+    onPrev: typeof onPrev;
+    onNext: typeof onNext;
+    goToStep: typeof goToStep;
+    activeIndex: import("vue").Ref<number, number>;
+    maxVisited: import("vue").Ref<number, number>;
+    isMobile: import("vue").Ref<boolean, boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update-step": (index: number, data: {
+        isVisited: boolean;
+    }) => void;
+    cancel: () => void;
+    final: () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToRuntimeProps<Props>, {
+    activeStep: number;
+    steps: () => never[];
+    showHeader: boolean;
+    showSummary: boolean;
+    dataLoading: boolean;
+    summary: () => {};
+    height: string;
+    canNext: boolean;
+    lazy: boolean;
+    minifySummery: boolean;
+    autoStepGuards: boolean;
+}>>> & Readonly<{
+    onCancel?: (() => any) | undefined;
+    "onUpdate-step"?: ((index: number, data: {
+        isVisited: boolean;
+    }) => any) | undefined;
+    onFinal?: (() => any) | undefined;
+}>, {
+    lazy: boolean;
+    summary: VcWizardSummaryType;
+    height: string | number;
+    steps: VcWizardStepType[];
+    activeStep: string | number;
+    showHeader: boolean;
+    showSummary: boolean;
+    dataLoading: boolean;
+    canNext: boolean;
+    minifySummery: boolean;
+    autoStepGuards: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, Partial<Record<string, (_: {
+    step: VcWizardStepType;
+    index: number;
+}) => any>> & {
+    "header-nav"?(_: {}): any;
+    "header-info"?(_: {}): any;
+    "final-actions"?(_: {}): any;
+    "extra-actions"?(_: {}): any;
+    navigation?(_: {}): 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/exports.d.ts

@@ -0,0 +1,163 @@
+import VcButton from './VcButton/VcButton.vue';
+import VcButtonIcon from './VcButton/VcButtonIcon.vue';
+import VcToggleButton from './VcButton/VcToggleButton.vue';
+import VcInput from './VcInput/VcInput.vue';
+import VcInputNumber from './VcInputNumber/VcInputNumber.vue';
+import VcInputError from './VcForm/UiComponents/VcInputError.vue';
+import VcInputLabel from './VcForm/UiComponents/VcInputLabel.vue';
+import VcSelect from './VcSelect/VcSelect.vue';
+import VcSelectGrouped from './VcSelect/VcSelectGrouped.vue';
+import VcSelectOption from './VcSelect/VcSelectOption.vue';
+import VcInfiniteScrollSelect from './VcSelect/VcInfiniteScrollSelect.vue';
+import VcAutocomplete from './VcAutocomplete/VcAutocomplete.vue';
+import VcCheckbox from './VcCheckbox/VcCheckbox.vue';
+import VcCheckboxGroup from './VcCheckboxGroup/VcCheckboxGroup.vue';
+import VcRadio from './VcRadio/VcRadio.vue';
+import VcRadioGroup from './VcRadioGroup/VcRadioGroup.vue';
+import VcRadioButtonsGroup from './VcRadioButtons/VcRadioButtonsGroup.vue';
+import VcSwitch from './VcSwitch/VcSwitch.vue';
+import VcSlider from './VcSlider/VcSlider.vue';
+import VcColorPicker from './VcColorPicker/VcColorPicker.vue';
+import VcDatePicker from './VcDatePicker/VcDatePicker.vue';
+import VcDatePickerPanel from './VcDatePickerPanel/VcDatePickerPanel.vue';
+import VcDatetimeRangePicker from './VcDatetimeRangePicker/VcDatetimeRangePicker.vue';
+import VcExtendedDatetimeRangePicker from './VcExtendedDatetimeRangePicker/VcExtendedDatetimeRangePicker.vue';
+import VcTimeInput from './VcTimeInput/VcTimeInput.vue';
+import VcPhoneInput from './VcPhoneInput/VcPhoneInput.vue';
+import VcTagInput from './VcTagInput/VcTagInput.vue';
+import VcOtpInput from './VcOtpInput/VcOtpInput.vue';
+import VcFileUploader from './VcFileUploader/VcFileUploader.vue';
+import VcCard from './VcCard/VcCard.vue';
+import VcModal from './VcModal/VcModal.vue';
+import VcConfirmModal from './VcModal/VcConfirmModal.vue';
+import VcPopover from './VcPopover/VcPopover.vue';
+import VcConfirmPopover from './VcPopover/VcConfirmPopover.vue';
+import VcSelectPopover from './VcPopover/VcSelectPopover.vue';
+import VcTabs from './VcTabs/VcTabs.vue';
+import VcTabNav from './VcTabs/VcTabNav.vue';
+import VcTabPane from './VcTabs/VcTabPane.vue';
+import VcVerticalTabs from './VcVerticalTabs/VcVerticalTabs.vue';
+import VcRadioTabs from './VcRadioTabs/VcRadioTabs.vue';
+import VcRadioTabsNav from './VcRadioTabs/UiComponents/VcRadioTabsNav.vue';
+import VcCollapse from './VcCollapse/VcCollapse.vue';
+import VcCollapseItem from './VcCollapse/VcCollapseItem.vue';
+import VcWizard from './VcWizard/VcWizard.vue';
+import VcDropdown from './VcDropdown/VcDropdown.vue';
+import VcDropdownItem from './VcDropdown/VcDropdownItem.vue';
+import VcTable from './VcTable/VcTable.vue';
+import VcPagination from './VcPagination/VcPagination.vue';
+import VcTree from './VcTree/VcTree.vue';
+import VcTreeSelect from './VcTree/VcTreeSelect.vue';
+import VcTransfer from './VcTransfer/VcTransfer.vue';
+import VcTag from './VcTag/VcTag.vue';
+import VcDelimitedList from './VcDelimitedList/VcDelimitedList.vue';
+import VcSparkline from './VcSparkline/VcSparkline.vue';
+import VcViewSwitcher from './VcViewSwitcher/VcViewSwitcher.vue';
+import VcSegmented from './VcSegmented/VcSegmented.vue';
+import VcLoading from './VcLoading/VcLoading.vue';
+import VcProgress from './VcProgress/VcProgress.vue';
+import VcProgressCircular from './VcProgress/VcProgressCircular.vue';
+import VcSkeletonLoader from './VcSkeletonLoader/VcSkeletonLoader.vue';
+import VcNotification from './VcNotification/VcNotification.vue';
+import VcForm from './VcForm/VcForm.vue';
+import VcFormItem from './VcForm/VcFormItem.vue';
+import VcSplitButton from './VcSplitButton/VcSplitButton.vue';
+import VcHyperLink from './VcHyperLink/VcHyperLink.vue';
+import VcIcon from './VcIcon/VcIcon.vue';
+import VcIconPicker from './VcIconPicker/VcIconPicker.vue';
+import VcMeterGroup from './VcMeterGroup/VcMeterGroup.vue';
+import VcMeterGroupLabel from './VcMeterGroup/VcMeterGroupLabel.vue';
+import VcMdEditor from './VcMdEditor/VcMdEditor.vue';
+import VcSystemUserPrompt from './VcSystemUserPrompt/VcSystemUserPrompt.vue';
+import VcSoundPlayer from './VcSoundplayer/VcSoundPlayer.vue';
+import VcJsonSchema from './VcJsonSchema/VcJsonSchema.vue';
+import VcHtmlEditor from './VcHtmlEditor/VcHtmlEditor.vue';
+import VcPdfDocument from './VcPdfViewer/VcPdfDocument.vue';
+import VcExcelFileUploader from './VcExcelUploader/VcExcelFileUploader.vue';
+import VcImageUploader from './VcImageUploader/VcImageUploader.vue';
+import VcTour from './VcTour/VcTour.vue';
+import VcSipFlow from './VcSipFlow/VcSipFlow.vue';
+export { VcButton, VcButtonIcon, VcToggleButton, VcInput, VcInputNumber, VcInputError, VcInputLabel, VcSelect, VcSelectGrouped, VcSelectOption, VcInfiniteScrollSelect, VcAutocomplete, VcCheckbox, VcCheckboxGroup, VcRadio, VcRadioGroup, VcRadioButtonsGroup, VcSwitch, VcSlider, VcColorPicker, VcDatePicker, VcDatePickerPanel, VcDatetimeRangePicker, VcExtendedDatetimeRangePicker, VcTimeInput, VcPhoneInput, VcTagInput, VcOtpInput, VcFileUploader, VcCard, VcModal, VcConfirmModal, VcPopover, VcConfirmPopover, VcSelectPopover, VcTabs, VcTabNav, VcTabPane, VcVerticalTabs, VcRadioTabs, VcRadioTabsNav, VcCollapse, VcCollapseItem, VcWizard, VcDropdown, VcDropdownItem, VcTable, VcPagination, VcTree, VcTreeSelect, VcTransfer, VcTag, VcDelimitedList, VcSparkline, VcViewSwitcher, VcSegmented, VcLoading, VcProgress, VcProgressCircular, VcSkeletonLoader, VcNotification, VcForm, VcFormItem, VcSplitButton, VcHyperLink, VcIcon, VcIconPicker, VcMeterGroup, VcMeterGroupLabel, VcMdEditor, VcSystemUserPrompt, VcSoundPlayer, VcJsonSchema, VcHtmlEditor, VcPdfDocument, VcExcelFileUploader, VcImageUploader, VcTour, VcSipFlow, };
+declare module '@vue/runtime-core' {
+    interface GlobalComponents {
+        VcButton: typeof VcButton;
+        VcButtonIcon: typeof VcButtonIcon;
+        VcToggleButton: typeof VcToggleButton;
+        VcInput: typeof VcInput;
+        VcInputNumber: typeof VcInputNumber;
+        VcInputError: typeof VcInputError;
+        VcInputLabel: typeof VcInputLabel;
+        VcSelect: typeof VcSelect;
+        VcSelectGrouped: typeof VcSelectGrouped;
+        VcSelectOption: typeof VcSelectOption;
+        VcInfiniteScrollSelect: typeof VcInfiniteScrollSelect;
+        VcAutocomplete: typeof VcAutocomplete;
+        VcCheckbox: typeof VcCheckbox;
+        VcCheckboxGroup: typeof VcCheckboxGroup;
+        VcRadio: typeof VcRadio;
+        VcRadioGroup: typeof VcRadioGroup;
+        VcRadioButtonsGroup: typeof VcRadioButtonsGroup;
+        VcSwitch: typeof VcSwitch;
+        VcSlider: typeof VcSlider;
+        VcColorPicker: typeof VcColorPicker;
+        VcDatePicker: typeof VcDatePicker;
+        VcDatePickerPanel: typeof VcDatePickerPanel;
+        VcDatetimeRangePicker: typeof VcDatetimeRangePicker;
+        VcExtendedDatetimeRangePicker: typeof VcExtendedDatetimeRangePicker;
+        VcTimeInput: typeof VcTimeInput;
+        VcPhoneInput: typeof VcPhoneInput;
+        VcTagInput: typeof VcTagInput;
+        VcOtpInput: typeof VcOtpInput;
+        VcFileUploader: typeof VcFileUploader;
+        VcCard: typeof VcCard;
+        VcModal: typeof VcModal;
+        VcConfirmModal: typeof VcConfirmModal;
+        VcPopover: typeof VcPopover;
+        VcConfirmPopover: typeof VcConfirmPopover;
+        VcSelectPopover: typeof VcSelectPopover;
+        VcTabs: typeof VcTabs;
+        VcTabNav: typeof VcTabNav;
+        VcTabPane: typeof VcTabPane;
+        VcVerticalTabs: typeof VcVerticalTabs;
+        VcRadioTabs: typeof VcRadioTabs;
+        VcRadioTabsNav: typeof VcRadioTabsNav;
+        VcCollapse: typeof VcCollapse;
+        VcCollapseItem: typeof VcCollapseItem;
+        VcWizard: typeof VcWizard;
+        VcDropdown: typeof VcDropdown;
+        VcDropdownItem: typeof VcDropdownItem;
+        VcTable: typeof VcTable;
+        VcPagination: typeof VcPagination;
+        VcTree: typeof VcTree;
+        VcTreeSelect: typeof VcTreeSelect;
+        VcTransfer: typeof VcTransfer;
+        VcTag: typeof VcTag;
+        VcDelimitedList: typeof VcDelimitedList;
+        VcSparkline: typeof VcSparkline;
+        VcViewSwitcher: typeof VcViewSwitcher;
+        VcSegmented: typeof VcSegmented;
+        VcLoading: typeof VcLoading;
+        VcProgress: typeof VcProgress;
+        VcProgressCircular: typeof VcProgressCircular;
+        VcSkeletonLoader: typeof VcSkeletonLoader;
+        VcNotification: typeof VcNotification;
+        VcForm: typeof VcForm;
+        VcFormItem: typeof VcFormItem;
+        VcSplitButton: typeof VcSplitButton;
+        VcHyperLink: typeof VcHyperLink;
+        VcIcon: typeof VcIcon;
+        VcIconPicker: typeof VcIconPicker;
+        VcMeterGroup: typeof VcMeterGroup;
+        VcMeterGroupLabel: typeof VcMeterGroupLabel;
+        VcMdEditor: typeof VcMdEditor;
+        VcSystemUserPrompt: typeof VcSystemUserPrompt;
+        VcSoundPlayer: typeof VcSoundPlayer;
+        VcJsonSchema: typeof VcJsonSchema;
+        VcHtmlEditor: typeof VcHtmlEditor;
+        VcPdfDocument: typeof VcPdfDocument;
+        VcExcelFileUploader: typeof VcExcelFileUploader;
+        VcImageUploader: typeof VcImageUploader;
+        VcTour: typeof VcTour;
+        VcSipFlow: typeof VcSipFlow;
+    }
+}

package/library/types/composables/input/useInputBase.d.ts

@@ -0,0 +1,27 @@
+import { IUseColorOptions, IUseColorProps } from './useInputColor';
+import { TIcon } from '../../types/icons.types';
+export interface IVcBaseInputProps extends IUseColorProps {
+    id?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    isError?: boolean;
+    emptyText?: string;
+    /**
+     * Icon shown before the input. Accepts a class string (legacy
+     * `vc-icon-*`) or a Vue component (e.g. a Lucide icon from
+     * `@lucide/vue`).
+     */
+    prefixIcon?: TIcon;
+    dataTestName?: string;
+    prefixIconSize?: string;
+    name?: string;
+    placeholder?: string;
+    maxWidth?: string | number;
+}
+export default function (props: IVcBaseInputProps, options: IUseColorOptions): {
+    prefixClasses: import("vue").ComputedRef<string[]>;
+    prefixStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+    inputClasses: import("vue").ComputedRef<string>;
+    maxWidthStyle: import("vue").ComputedRef<string>;
+    prefixIcon: import("vue").ComputedRef<TIcon>;
+};

package/library/types/composables/input/useInputColor.d.ts

@@ -0,0 +1,25 @@
+import { COMPONENT_COLOR_TYPE } from '../../enum/constants';
+import { TIcon } from '../../types/icons.types';
+export interface IUseColorProps {
+    prefixIconColor?: COMPONENT_COLOR_TYPE | string;
+    color?: COMPONENT_COLOR_TYPE;
+    /**
+     * Icon shown before the input. Accepts a class string (legacy
+     * `vc-icon-*`) or a Vue component (e.g. a Lucide icon from
+     * `@lucide/vue`).
+     */
+    prefixIcon?: TIcon;
+    prefixIconSize?: string;
+}
+export interface IUseColorOptions {
+    colorClass?: string;
+    iconColorClass?: string;
+    iconSizeClass?: string;
+    defaultPrefixIcon?: TIcon;
+}
+export default function (propsData: IUseColorProps, options: IUseColorOptions): {
+    prefixStyle: import("vue").ComputedRef<import("vue").CSSProperties>;
+    inputClasses: import("vue").ComputedRef<string>;
+    prefixClasses: import("vue").ComputedRef<string[]>;
+    prefixIcon: import("vue").ComputedRef<TIcon>;
+};

package/library/types/composables/input/useInputLabel.d.ts

@@ -0,0 +1,15 @@
+import { TIcon } from '../../types/icons.types';
+export declare const BASE_LABEL_TOOLTIP_WIDTH = 180;
+export interface IUseInputLabelProps {
+    required?: boolean;
+    label?: string;
+    /**
+     * 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;
+}
+export declare const labelTooltipInfoWidth: (width?: string | number) => string;

package/library/types/composables/option/useOptionMethods.d.ts

@@ -0,0 +1,19 @@
+import { ConfigOptionType, ExtractValueType, OptionMappedType, OptionObjectValueType, OptionValueType } from '../../types';
+import { COMPONENT_COLOR_TYPE } from '../../enum/constants';
+import { StyleValue } from 'vue';
+import type { TIcon } from '../../types/icons.types';
+export declare function isOptionObjectValueType(option: OptionValueType): option is OptionObjectValueType;
+export default function useOptionMethods(): {
+    optionValue: <Option extends OptionValueType, Config extends ConfigOptionType<Option>, Model extends ExtractValueType<Option, Config>>(option: Option, config?: Config | undefined) => Model;
+    optionLabel: <Option_1 extends OptionValueType, Config_1 extends ConfigOptionType<Option_1>>(option: Option_1, config?: Config_1 | undefined) => string;
+    optionIcon: <Option_2 extends OptionValueType, Config_2 extends ConfigOptionType<Option_2>>(option: Option_2, config?: Config_2 | undefined) => TIcon;
+    optionDisabled: <Option_3 extends OptionValueType, Config_3 extends ConfigOptionType<Option_3>>(option: Option_3, config?: Config_3 | undefined) => boolean;
+    optionIconColorHex: <Option_4 extends OptionValueType, Config_4 extends ConfigOptionType<Option_4>>(option: Option_4, config?: Config_4 | undefined) => string;
+    optionClass: <Option_5 extends OptionValueType, Config_5 extends ConfigOptionType<Option_5>>(option: Option_5, config: Config_5) => string;
+    optionStyle: <Option_6 extends OptionValueType, Config_6 extends ConfigOptionType<Option_6>>(option: Option_6, config?: Config_6 | undefined) => string;
+    optionSearchKeys: <Option_7 extends OptionValueType, Config_7 extends ConfigOptionType<Option_7>>(option: Option_7, config?: Config_7 | undefined) => Array<string>;
+    optionSearch: <Option_8 extends OptionValueType, Config_8 extends ConfigOptionType<Option_8>>(query: string, options: Option_8[], config?: Config_8 | undefined) => Option_8[];
+    optionColor: <Option_9 extends OptionValueType, Config_9 extends ConfigOptionType<Option_9>>(option: Option_9, config?: Config_9 | undefined) => COMPONENT_COLOR_TYPE;
+    optionListMap: <Option_10 extends OptionValueType, Config_10 extends ConfigOptionType<Option_10>>(options: Option_10[], config?: Config_10 | undefined) => OptionMappedType<Option_10, Config_10>[];
+    optionIconStyle: <Option_11 extends OptionValueType, Config_11 extends ConfigOptionType<Option_11>>(option: Option_11, config?: Config_11 | undefined) => StyleValue;
+};

package/library/types/composables/useConfirmModal.d.ts

@@ -0,0 +1,30 @@
+import { Ref, VNode } from 'vue';
+declare global {
+    interface VcGlobalSingletons {
+        confirmModalState: Ref<ConfirmObjectType>;
+    }
+}
+type paramsType = {
+    header?: string;
+    type?: 'confirm' | 'save' | 'edit' | 'delete';
+    message?: string;
+    renderContent?: VNode;
+    modalConfirmLabel?: string;
+    modalCancelLabel?: string;
+};
+type ConfirmObjectType = {
+    open: boolean;
+    header: string;
+    type: string;
+    message: string;
+    renderContent: VNode | undefined;
+    openModal: (params: paramsType) => void;
+    closeModal: () => void;
+    modalConfirmLabel?: string;
+    modalCancelLabel?: string;
+    onClose?: () => void;
+    onConfirm?: () => void;
+};
+export declare const confirmModalState: Ref<ConfirmObjectType>;
+declare const useConfirmModal: (params: paramsType) => Promise<boolean>;
+export default useConfirmModal;

package/library/types/composables/useConfirmPopup.d.ts

@@ -0,0 +1,9 @@
+import { TConfirmPopupObject, TConfirmPopupParams } from '../types';
+declare global {
+    interface VcGlobalSingletons {
+        confirmPopupState: TConfirmPopupObject;
+    }
+}
+export declare const confirmPopupState: TConfirmPopupObject;
+declare const useConfirmPopup: (params: TConfirmPopupParams) => Promise<unknown>;
+export default useConfirmPopup;

package/library/types/directives/index.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    'click-outside': import("vue").ObjectDirective<HTMLElement, any, string, any>;
+};
+export default _default;

package/library/types/directives/input-mask.d.ts

@@ -0,0 +1,2 @@
+import { vMaska } from 'maska/vue';
+export default vMaska;

package/library/types/entity/components/Button/VcEntityAddButton.vue.d.ts

@@ -0,0 +1,41 @@
+import { BaseEntityServiceImplements } from '../..';
+declare const _default: <Entity extends BaseEntityServiceImplements>(__VLS_props: {
+    label?: string | undefined;
+    entity: Entity;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: any;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        label?: string | undefined;
+        entity: Entity;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: any;
+}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            label?: string | undefined;
+            entity: Entity;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default?(_: {}): any;
+        };
+        emit: any;
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/library/types/entity/components/Button/VcEntityCancelButton.vue.d.ts

@@ -0,0 +1,53 @@
+import { BaseEntityServiceImplements } from '../..';
+declare const _default: <Entity extends BaseEntityServiceImplements, EntityData extends Record<string, unknown>>(__VLS_props: {
+    label?: string | undefined;
+    entity: Entity;
+    entityData: EntityData;
+    readonly onCancel?: (() => any) | undefined;
+    useConfirm?: boolean | undefined;
+    confirmMessage?: string | undefined;
+} & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, __VLS_ctx?: {
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: (e: 'cancel') => void;
+} | undefined, __VLS_expose?: ((exposed: import('vue').ShallowUnwrapRef<{}>) => void) | undefined, __VLS_setup?: Promise<{
+    props: {
+        label?: string | undefined;
+        entity: Entity;
+        entityData: EntityData;
+        readonly onCancel?: (() => any) | undefined;
+        useConfirm?: boolean | undefined;
+        confirmMessage?: string | undefined;
+    } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {
+        default?(_: {}): any;
+    };
+    emit: (e: 'cancel') => void;
+}>) => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> & {
+    __ctx?: {
+        props: {
+            label?: string | undefined;
+            entity: Entity;
+            entityData: EntityData;
+            readonly onCancel?: (() => any) | undefined;
+            useConfirm?: boolean | undefined;
+            confirmMessage?: string | undefined;
+        } & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps;
+        expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+        attrs: any;
+        slots: {
+            default?(_: {}): any;
+        };
+        emit: (e: 'cancel') => void;
+    } | undefined;
+};
+export default _default;
+type __VLS_Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};