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

package/library/types/types/ExcelParser.types.d.ts

@@ -0,0 +1,148 @@
+import type { CellObject } from 'xlsx';
+export declare type RuleResultType = {
+    valid: boolean;
+    type: string;
+};
+export declare type ResultValidData = {
+    valid: boolean;
+    errors: Array<RuleResultType>;
+};
+export declare type ErrorRowType = {
+    column: string;
+    errors: ResultValidData;
+};
+export declare type BindingErrorsType = {
+    row: number;
+    errors: Array<ErrorRowType>;
+};
+export declare type TValidationRules = {
+    required?: boolean;
+    numeric?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    alphaNum?: boolean;
+};
+export declare type ValueOf<T> = T[keyof T];
+/**
+ * Runtime contract of a single validation rule. Rules receive the cell value
+ * and an optional option (e.g. minLength) and return a result describing
+ * whether the value satisfies the rule.
+ */
+export declare type ValidationFunctionType = (value: unknown, opt?: number | boolean) => RuleResultType;
+export declare type RulesObjectType = {
+    [key in keyof TValidationRules]: ValidationFunctionType;
+};
+export declare type NormalizeHeaderOptionType = {
+    key: string;
+    value: string;
+};
+export declare type OptionsType = {
+    hasHeader: boolean;
+    normalizeHeader?: NormalizeHeaderOptionType;
+};
+export declare type FileObjectType = {
+    fileName: string;
+    size: number;
+    content?: string | ArrayBuffer | null;
+};
+/**
+ * Raw cell value as produced by xlsx `sheet_to_json`. Cells can be primitives,
+ * dates, or the rich `CellObject` shape when the consumer pulls metadata.
+ */
+export declare type ParsedCellValue = string | number | boolean | Date | null | CellObject;
+/**
+ * Single parsed sheet row keyed by header name. xlsx may emit any cell value
+ * type, so consumers should narrow before display.
+ */
+export declare type ParsedRow = Record<string, ParsedCellValue>;
+export declare type ParserDataObjectType = {
+    sheetName: string;
+    countRows: number;
+    header: Array<string>;
+    cols: Array<{
+        key: number;
+        name: string;
+    }>;
+    data: Array<ParsedRow>;
+};
+export declare type ValidationOptionsType = {
+    [key in keyof TValidationRules]: ValueOf<TValidationRules>;
+};
+export declare type BindingInnerHeader = {
+    key: string;
+    property: string;
+    prefix?: string;
+};
+export declare type BindingHeaderObjectType = {
+    key: string;
+    property: string;
+    validationOptions: ValidationOptionsType;
+    inner?: Array<BindingInnerHeader>;
+};
+export declare type BindingsModelObjectType = {
+    key: string;
+    property: string;
+    type: string;
+    validationOptions: ValidationOptionsType;
+    inner?: Array<BindingInnerHeader>;
+};
+export declare type BindRowErrorObjectType = {
+    row: number;
+    errors: {
+        column: string;
+        errors: {
+            valid: boolean;
+            errors: {
+                type: string;
+                valid: boolean;
+            }[];
+        };
+    }[];
+};
+/**
+ * A bound row produced by the excel parser. Generic over the cell value so
+ * consumers that know the expected column types can parameterise (e.g.
+ * `BindingRowItemType<string>`), while the parser itself treats values as
+ * `unknown` and narrows at usage sites. Inner-mapped columns also produce
+ * nested object values, which are covered by the default `unknown`.
+ *
+ * Because TS forbids an index signature whose value type doesn't subsume the
+ * declared `ID: number` property, the index signature widens to
+ * `TValue | number`.
+ */
+export declare type BindingRowItemType<TValue = unknown> = {
+    ID: number;
+    [key: string]: TValue | number;
+};
+export declare type ValidateRowReturnType = {
+    valid: boolean;
+    row?: number;
+    errors: Array<ErrorRowType>;
+};
+/**
+ * Alias kept for backwards compatibility with consumer code that types
+ * uploader payloads by their cell value type. Equivalent to
+ * `BindingRowItemType<T>` so values flow without conversion between the
+ * parser and the uploader UI.
+ */
+export declare type BindResultObjectType<T> = BindingRowItemType<T>;
+export declare type BindTableHeaderObjectType = {
+    columnItemKey: string;
+    columnItemLabel: string;
+    key: string;
+    property: string;
+    type: string;
+    validationOptions: ValidationOptionsType;
+    inner: Array<BindingInnerHeader>;
+};
+export declare type SelectedRowObjectType<T> = BindingRowItemType<T> & {
+    selected?: boolean;
+};
+export declare type BindDataRowUpdateType = {
+    [key: string]: string | number;
+    ID: number;
+};
+export declare type BindDataRowUpdateModalType = {
+    row: BindDataRowUpdateType;
+    id: number;
+};

package/library/types/types/OptionAndConfig.types.d.ts

@@ -0,0 +1,34 @@
+import type { StyleValue } from 'vue';
+import { COMPONENT_COLOR_TYPE } from '../enum/constants';
+import { NestedKeys, PathValue } from '.';
+import type { TIcon } from './icons.types';
+export type OptionObjectValueType = Record<string, unknown>;
+export type OptionNonObjectValueType = string | number | boolean;
+export type OptionValueType = OptionObjectValueType | OptionNonObjectValueType;
+export type ConfigOptionType<Option extends OptionValueType> = Option extends OptionObjectValueType ? {
+    valueKey: NestedKeys<Option>;
+    labelKey?: NestedKeys<Option>;
+    iconKey?: NestedKeys<Option>;
+    colorKey?: NestedKeys<Option>;
+    onClickFuncKey?: NestedKeys<Option>;
+    onClickSkipKey?: NestedKeys<Option>;
+    iconColorHex?: NestedKeys<Option>;
+    searchKey?: NestedKeys<Option> | Array<NestedKeys<Option>>;
+    disabledKey?: NestedKeys<Option>;
+    classKey?: NestedKeys<Option>;
+    styleKey?: NestedKeys<Option>;
+    optionIconStyleKey?: NestedKeys<Option>;
+} : never;
+export type ExtractValueType<Option extends OptionValueType, Config extends ConfigOptionType<Option>> = Option extends OptionObjectValueType ? Config extends {
+    valueKey: infer Key;
+} ? Key extends NestedKeys<Option> ? PathValue<Option, Key> : Option : Option : Option;
+export type OptionMappedType<Option extends OptionValueType, Config extends ConfigOptionType<Option>> = {
+    originalItem: Option;
+    value: ExtractValueType<Option, Config>;
+    label: string;
+    disabled: boolean;
+    icon: TIcon;
+    color: COMPONENT_COLOR_TYPE;
+    iconStyle: StyleValue;
+    key: string;
+};

package/library/types/types/Tabs.d.ts

@@ -0,0 +1,22 @@
+import { Ref } from 'vue';
+import type { TIcon } from '.';
+export type VcEntityTabType<EntityData> = {
+    name: string;
+    label: string;
+    icon?: TIcon;
+    navClass?: string;
+    entityData?: EntityData;
+    disabled?: boolean;
+};
+export type VcEntityEditableTabSlotData<EntityData> = {
+    entity: EntityData;
+    tabData: VcEntityTabType<EntityData>;
+    index: number;
+};
+export type VcEditableTabsEditModelType<EntityData extends Record<string, unknown> = Record<string, unknown>> = {
+    [key: string | number]: Ref<EntityData>;
+};
+export type VcEditableTabsDataProvideParamType<EntityData extends Record<string, unknown> = Record<string, unknown>> = {
+    editableModels: Ref<VcEditableTabsEditModelType<EntityData>>;
+    updateEditableModel?: (param: Ref<EntityData>) => void;
+};

package/library/types/types/VcDropdown.types.d.ts

@@ -0,0 +1,53 @@
+import type { CSSProperties } from 'vue';
+import { COMPONENT_COLOR_TYPE, COMPONENT_SIZE_TYPE } from '../enum/constants';
+import { PopoverPlacementType } from './VcPopover.types';
+import type { TIcon } from './icons.types';
+export type VcDropdownFn = (...args: Array<unknown>) => void;
+export type VcDropdownOption = {
+    label?: string;
+    labelClass?: string;
+    contentClass?: string;
+    /**
+     * Icon shown before the dropdown item label. Accepts a class string
+     * (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide icon from
+     * `@lucide/vue`).
+     */
+    icon?: TIcon;
+    /**
+     * Extra CSS classes for the icon. Useful when the icon is a Vue
+     * component (Lucide) and you still want utility classes like
+     * `text-success` applied to it.
+     */
+    iconClass?: string;
+    disabled?: boolean;
+    divided?: boolean;
+    value?: string | number | Record<string, unknown> | VcDropdownFn;
+    color?: COMPONENT_COLOR_TYPE;
+};
+export type VcDropdownProps = {
+    options?: Array<VcDropdownOption>;
+    size?: COMPONENT_SIZE_TYPE;
+    maxHeight?: string | number;
+    disabled?: boolean;
+    placement?: PopoverPlacementType;
+    effect?: 'dark' | 'light' | string;
+    trigger?: 'click' | 'hover' | 'contextmenu';
+    triggerKeys?: Array<string>;
+    virtualTriggering?: boolean;
+    virtualRef?: HTMLElement;
+    hideOnClick?: boolean;
+    showArrow?: boolean;
+    showTimeout?: number;
+    hideTimeout?: number;
+    role?: 'dialog' | 'grid' | 'group' | 'listbox' | 'menu' | 'navigation' | 'tooltip' | 'tree';
+    tabindex?: number;
+    popperClass?: string;
+    popperStyle?: string | CSSProperties;
+    popperOptions?: Record<string, unknown>;
+    teleported?: boolean;
+    appendTo?: string | HTMLElement;
+    persistent?: boolean;
+    labelClass?: string;
+    contentClass?: string;
+    color?: COMPONENT_COLOR_TYPE;
+};

package/library/types/types/VcEditableTabs.types.d.ts

@@ -0,0 +1,4 @@
+import { Ref } from 'vue';
+import VcEntityEditableTabs from '../entity/components/Tabs/VcEntityEditableTabs.vue';
+import { ComponentExposed } from 'vue-component-type-helpers';
+export declare type EditableTabsRef = Ref<ComponentExposed<typeof VcEntityEditableTabs> | null | undefined>;

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

@@ -0,0 +1,10 @@
+export interface FileUploaded extends File {
+    id?: number;
+    /**
+     * Either a reference back to the source `File` (file mode) or the
+     * base64-decoded payload (base64 mode). Always populated by the
+     * `toFileUploaded` / `fromBase64Result` helpers in `VcFileUploader`.
+     */
+    File: string | ArrayBuffer | null | File;
+}
+export type ReturnFileType = 'base64' | 'file';

package/library/types/types/VcMdEditor.types.d.ts

@@ -0,0 +1,18 @@
+import type { JSONSchema7 } from 'json-schema';
+export type TMDEditorParameterItem = {
+    label: string;
+    tag: string;
+    description?: string;
+    schema?: JSONSchema7;
+};
+export type TMDEditorGroupParameterItems = {
+    label: string;
+    options: Array<TMDEditorParameterItem>;
+};
+export type TMDEditorParameterOption = TMDEditorParameterItem | TMDEditorGroupParameterItems;
+export type BlockValidationIssue = {
+    tag: string;
+    line: number;
+    type: 'unclosed' | 'unopened';
+};
+export declare function isGroupParameter(item: TMDEditorParameterOption): item is TMDEditorGroupParameterItems;

package/library/types/types/VcMeterGroup.types.d.ts

@@ -0,0 +1,25 @@
+import { TIcon } from './icons.types';
+export interface IMeterItem {
+    /**
+     * Current label of the meter item.
+     */
+    label: string;
+    /**
+     * Current value of the meter item.
+     */
+    value: number;
+    /**
+     * Current color of the meter item.
+     */
+    color?: string;
+    /**
+     * Current icon of the meter item.
+     * Accepts a class string (legacy `vc-icon-*`) or a Vue component
+     * (e.g. a Lucide icon from `@lucide/vue`).
+     */
+    icon?: TIcon;
+    /**
+     * percent value for label
+     */
+    percent?: string;
+}

package/library/types/types/VcPopover.types.d.ts

@@ -0,0 +1,71 @@
+import { ButtonColor, ButtonSize, ButtonType } from './VcButton.types';
+import { TIcon } from './icons.types';
+import { ComponentPublicInstance, VNode } from 'vue';
+export declare type PopoverTriggerType = 'click' | 'focus' | 'hover' | 'contextmenu' | 'manual';
+export declare type PopoverPlacementType = 'top-start' | 'top' | 'top-end' | 'bottom-start' | 'bottom' | 'bottom-end' | 'left-start' | 'left' | 'left-end' | 'right-start' | 'right' | 'right-end';
+export declare type PopoverThemeType = 'dark' | 'light';
+/**
+ * Anything el-popover's `virtual-ref` accepts as an anchor: a CSS selector,
+ * a raw DOM `Element`, or a Vue component instance (whose `$el` is used).
+ * Kept as a named alias so the popup APIs read self-documenting and the
+ * narrowing in `VcConfirmPopover` stays in sync if el-popover's contract
+ * widens.
+ */
+export declare type ElPopoverVirtualRef = string | Element | ComponentPublicInstance;
+export declare type TPConfirmActionsParams = {
+    label?: string;
+    color?: ButtonColor;
+    /**
+     * Accepts a class string (legacy `vc-icon-*`) or a Vue component
+     * (e.g. a Lucide icon from `@lucide/vue`).
+     */
+    icon?: TIcon;
+    size?: ButtonSize;
+    type?: ButtonType;
+};
+export declare type TConfirmPopupParams = {
+    target: ElPopoverVirtualRef;
+    header?: string;
+    icon?: TIcon;
+    iconClasses?: string;
+    type?: 'confirm' | 'save' | 'edit' | 'delete';
+    message?: string;
+    renderContent?: VNode;
+    placement?: PopoverPlacementType;
+    popoverWidth?: string | number;
+    popoverMaxWidth?: string | number;
+    confirmAction?: TPConfirmActionsParams;
+    cancelAction?: TPConfirmActionsParams;
+    confirm?: () => void;
+    cancel?: () => void;
+};
+export declare type TConfirmPopupObject = {
+    target: ElPopoverVirtualRef;
+    open: boolean;
+    header?: string;
+    type: string;
+    icon?: TIcon;
+    iconClasses?: string;
+    message: string;
+    popoverMaxWidth?: string | number;
+    renderContent: VNode | undefined;
+    placement: PopoverPlacementType | undefined;
+    openPopup: (params: TConfirmPopupParams) => void;
+    closePopup: () => void;
+    onClose?: () => void;
+    onConfirm?: () => void;
+    confirmAction?: TPConfirmActionsParams;
+    cancelAction?: TPConfirmActionsParams;
+};
+export declare type TPopConfirmOptions = {
+    themeEffect?: PopoverThemeType;
+    placement?: PopoverPlacementType;
+    persistent?: boolean;
+    popoverClass?: string;
+    teleported?: boolean;
+    mouseEvent?: boolean;
+    offset?: number;
+    delayClose?: number;
+    actionSize?: ButtonSize;
+    confirmActionColor?: ButtonColor;
+};

package/library/types/types/VcSipFlow.types.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Keys of `T` whose value type is something we can use as an item id —
+ * a string, a number, or undefined. Filters out object/unknown fields like
+ * `MessageFlowType.objectData` so `VcSipFlow`'s `messageKey` prop can only
+ * point at a usable identifier and the lookup returns `string | number |
+ * undefined` without runtime narrowing.
+ */
+export declare type IdFieldKey<T> = {
+    [K in keyof T]-?: NonNullable<T[K]> extends string | number ? K : never;
+}[keyof T];
+export declare type MessageFlowType = {
+    callId: string;
+    from: string;
+    to: string;
+    date: number;
+    message?: string;
+    eventType?: string;
+    label?: string;
+    objectData?: unknown;
+    x1?: number;
+    x2?: number;
+    _id?: number | string;
+    reason_phrase?: string;
+    serverIcon?: string;
+    dateLabel?: string;
+    dateNano?: number;
+    code?: string | number;
+};
+export declare type AliasType = {
+    alias: string;
+    original: string;
+};
+export declare type SortFunctionType = (itemA: MessageFlowType, itemB: MessageFlowType) => number;
+export declare type SipMessageFlowType = Omit<MessageFlowType, 'x1' | 'x2'> & {
+    x1: number;
+    x2: number;
+};
+export declare interface ISipFlowOptions {
+    /** Vertical offset between messages, default 60 */
+    verticalSpace?: number;
+    /** DY attribute for server, default 28 */
+    headerNameDY?: number;
+    /** uses for vertTopAliasOffset, default 20 */
+    headerLineOffset?: number;
+    /** uses for vertTopAliasOffset, default 20 */
+    aliasItemSpace?: number;
+    /** SVG Bottom Offset, default 120 */
+    svgBottomSpace?: number;
+    /** Min Flow Height, default 420 */
+    minHeight?: number;
+    /** Default Line Color (top message text), default '#6578ae' */
+    colorLineMessage?: string;
+    /** Default Arrow Color, default '#5a73b5' */
+    colorArrow?: string;
+    /** Label Color, default '#8292aa' */
+    colorLabel?: string;
+    /**
+     *  Array of arrow colors,
+     *  default
+     * [
+     *     '#880E4F',
+     *     '#00796B',
+     *     '#004cca',
+     *     '#6200EA',
+     *     '#4e9298',
+     *     '#b70c3d',
+     *     '#827717',
+     *     '#E65100',
+     *     '#D50000',
+     *     '#2E7D32'
+     * ]
+     */
+    colorsColumnArrow?: Array<string>;
+    /** Status Colors,
+     *  Type { [key: string]: { color: string, name: string } },
+     *  Ex: {1: { color: '#80D035', name: '1xx'}}
+     */
+    statusColors?: {
+        [key: string]: {
+            color: string;
+            name: string;
+        };
+    };
+    /** List Icons
+     * Uses icons from VC-icon font by default
+     * Ex: {INVITE: '&#xe96e;...'}
+     */
+    listIcons?: Record<string, string>;
+    /** List of Server Icons
+     * Ex: { Default: '/svg/sip/OpenSIPS.svg#icon', ... }
+     */
+    listServerIcons?: Record<string, string>;
+    /** Vertical Line Min Offset */
+    verticalLineMinOffset?: number;
+}

package/library/types/types/VcSoundPlayer.types.d.ts

@@ -0,0 +1,34 @@
+import type { Ref } from 'vue';
+import type { WaveSurferOptions } from 'wavesurfer.js';
+export declare type VcSoundPlayerSize = 'sm' | 'md';
+export declare type VcSoundDownloads = Array<string>;
+export declare type VcSoundPlayerProvideType = {
+    componentId: string;
+    options?: Ref<WaveSurferOptions>;
+    isInitialized?: Ref<boolean>;
+    loading?: Ref<boolean>;
+    isPlaying?: Ref<boolean>;
+    isInitSound?: Ref<boolean>;
+    showReset?: Ref<boolean>;
+    duration?: Ref<number>;
+    speed?: Ref<number>;
+    currentTime?: Ref<number>;
+    volume?: Ref<number>;
+    defaultVolume?: () => number;
+    isPlayingInProgress?: Ref<boolean>;
+    initWavesurfer?: (id: string, el?: HTMLElement) => void;
+    play?: () => void;
+    pause?: () => void;
+    stop?: () => void;
+    skipBackward?: (seconds?: number) => void;
+    skipForward?: (seconds?: number) => void;
+    setPlaybackRate?: (speed: number) => void;
+};
+export type HoverPluginOptions = {
+    lineColor?: string;
+    lineWidth?: string | number;
+    labelColor?: string;
+    labelSize?: string | number;
+    labelBackground?: string;
+    formatTimeCallback?: (seconds: number) => string;
+};

package/library/types/types/VcSparkline.types.d.ts

@@ -0,0 +1,27 @@
+export type VcSpSelectItemKey<T = Record<string, unknown>> = boolean | null | undefined | string | readonly (string | number)[] | ((item: T, fallback?: unknown) => unknown);
+export type VcSparklineItem = number | {
+    value: number;
+};
+export interface VcSpPoint {
+    x: number;
+    y: number;
+    value: number;
+}
+export interface VcSpBoundary {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}
+export type SparklineText = {
+    x: number;
+    value: string;
+};
+export interface VcSpBar {
+    x: number;
+    y: number;
+    height: number;
+    value: number;
+}
+export type VcSpLineType = 'trend' | 'bar';
+export type VcSpGradientDirection = 'top' | 'bottom' | 'left' | 'right';

package/library/types/types/VcSplitButton.types.d.ts

@@ -0,0 +1,15 @@
+import { COMPONENT_COLOR_TYPE, COMPONENT_SIZE_TYPE } from '../enum/constants';
+import { TIcon } from './icons.types';
+export declare type VcSplitButtonColor = COMPONENT_COLOR_TYPE | undefined;
+export declare type VcSplitButtonSize = COMPONENT_SIZE_TYPE | undefined;
+export declare type VcSplitButtonOption = {
+    label: string;
+    /**
+     * Icon shown before the option label. Accepts a class string (legacy
+     * `vc-icon-*`) or a Vue component (e.g. a Lucide icon from
+     * `@lucide/vue`).
+     */
+    icon?: TIcon;
+    clickFunction?: unknown;
+};
+export declare type VcSplitButtonOptions = Array<VcSplitButtonOption>;

package/library/types/types/VcTable.types.d.ts

@@ -0,0 +1,73 @@
+import { OptionObjectValueType } from '.';
+import { TIcon } from './icons.types';
+export declare type Alignment = 'left' | 'center' | 'right';
+export declare type SortFunction<Option extends OptionObjectValueType> = (a: Option, b: Option) => number;
+export declare type FormatFunction<Option extends OptionObjectValueType = OptionObjectValueType> = (row: Option) => string | number | unknown;
+/** @description Configuration for column filtering functionality */
+export declare type FilterableConfig = {
+    /** @description Whether filtering is enabled for this column */
+    enabled: boolean;
+    /** @description Whether to show a search input in the filter popover to narrow down options */
+    searchable?: boolean;
+};
+/** @description State object tracking active filters per column */
+export declare type ColumnFilterState = {
+    [columnKey: string]: Array<string | number>;
+};
+/** @description Default filter options per column (always shown in filter popover) */
+export declare type FilterOptionsMap = Record<string, Array<string | number>>;
+export declare type ColumnTypeItem<Option extends OptionObjectValueType = OptionObjectValueType> = {
+    columnItemLabel: string;
+    columnItemKey: string;
+    /**
+     * @description Icon shown in the column header. Accepts a class
+     * string (legacy `vc-icon-*`) or a Vue component (e.g. a Lucide
+     * icon from `@lucide/vue`).
+     */
+    columnItemIcon?: TIcon;
+    columnAlignment?: Alignment;
+    columnClasses?: string;
+    rowItemAlignment?: Alignment;
+    rowItemLabelKey?: string;
+    rowItemKeyKey?: string;
+    rowItemClasses?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    width?: string;
+    selected?: boolean;
+    sortBy?: string;
+    sortableFunction?: SortFunction<Option>;
+    /** @description Format function to customize cell value display. Receives the row object and returns the formatted value. */
+    format?: FormatFunction<Option>;
+    /** @description Configuration for column filtering. When enabled, displays a filter icon that opens a popover with unique values to filter by. */
+    filterableConfig?: FilterableConfig;
+};
+export declare type ColumnType = Array<ColumnTypeItem>;
+export declare type ConfigType = {
+    optionUniqueKey?: string;
+    disabledKey?: string;
+    [key: string]: string | undefined;
+};
+export declare type SortingOrderDefaultType = {
+    columnName: string;
+    order: string;
+} | undefined;
+export interface Pagination {
+    currentPage: number;
+    perPage: number;
+    total: number;
+}
+export declare type PaginationProp = Pagination | undefined;
+export declare type ActionsColumnType = {
+    width?: string;
+    minWidth?: string;
+    maxWidth?: string;
+    columnName?: string;
+    /**
+     * @description Icon shown in the actions column header. Accepts a
+     * class string (legacy `vc-icon-*`) or a Vue component (e.g. a
+     * Lucide icon from `@lucide/vue`).
+     */
+    icon?: TIcon;
+    classes?: string;
+};

package/library/types/types/VcTabs.types.d.ts

@@ -0,0 +1,37 @@
+import { TIcon } from './icons.types';
+export declare type VcTabPanePropsShape = {
+    name?: string;
+    disabled?: boolean;
+    icon?: TIcon;
+    label?: string;
+    closable?: boolean;
+    lazy?: boolean;
+    navClass?: string;
+    index?: number;
+    [key: string]: unknown;
+};
+export declare type VcPaneType = {
+    paneName: string;
+    active: boolean;
+    label: string;
+    disabled: boolean;
+    isClosable: boolean;
+    index?: number;
+    icon?: TIcon;
+    props: VcTabPanePropsShape;
+    slots?: Record<string, unknown>;
+    tabData?: unknown;
+    navClass?: string;
+};
+export declare type VcTabsNavigationType = 'default' | 'card';
+export declare type VcTabsProvideType = {
+    tabActiveName: () => string;
+    registerPane: (pane: VcPaneType) => void;
+    unregisterPane: (paneName: string) => void;
+    setCurrentName: (name?: string) => void;
+    openByFormValidate: boolean;
+};
+export declare type VcTabPaneProvideType = {
+    tabName: string;
+    openByValidateError: (tabName: string) => void;
+};