import * as i0 from '@angular/core';
import { EventEmitter, OnInit, QueryList, ElementRef, OnChanges, SimpleChanges, AfterViewInit, OnDestroy } from '@angular/core';

type ButtonVariant = 'primary' | 'ghost' | 'subtle' | 'outline' | 'danger';
declare class VspButton {
    variant: ButtonVariant;
    size: 'sm' | 'md' | 'lg';
    loading: boolean;
    loadingText?: string;
    fullWidth: boolean;
    disabled: boolean;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspButton, "vsp-button", never, { "variant": { "alias": "variant"; "required": false; }; "size": { "alias": "size"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "loadingText": { "alias": "loadingText"; "required": false; }; "fullWidth": { "alias": "fullWidth"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}

type BadgeTone = 'pos' | 'neg' | 'warn' | 'info' | 'muted';
declare class VspBadge {
    tone: BadgeTone;
    dot: boolean;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBadge, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBadge, "vsp-badge", never, { "tone": { "alias": "tone"; "required": false; }; "dot": { "alias": "dot"; "required": false; }; }, {}, never, ["*"], true, never>;
}

declare class VspTag {
    remove: EventEmitter<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTag, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTag, "vsp-tag", never, {}, { "remove": "remove"; }, never, ["*"], true, never>;
}
declare class VspKbd {
    static ɵfac: i0.ɵɵFactoryDeclaration<VspKbd, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspKbd, "vsp-kbd", never, {}, {}, never, ["*"], true, never>;
}
declare class VspDivider {
    vertical: boolean;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDivider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDivider, "vsp-divider", never, { "vertical": { "alias": "vertical"; "required": false; }; }, {}, never, never, true, never>;
}

type AvatarStatus = 'online' | 'offline' | 'away' | 'busy';
declare class VspAvatar {
    name: string;
    hue: number;
    size: number;
    src?: string;
    alt?: string;
    status?: AvatarStatus;
    shape: 'circle' | 'square';
    get initials(): string;
    get radius(): string;
    get dot(): number;
    get statusColor(): string;
    get bg(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAvatar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAvatar, "vsp-avatar", never, { "name": { "alias": "name"; "required": false; }; "hue": { "alias": "hue"; "required": false; }; "size": { "alias": "size"; "required": false; }; "src": { "alias": "src"; "required": false; }; "alt": { "alias": "alt"; "required": false; }; "status": { "alias": "status"; "required": false; }; "shape": { "alias": "shape"; "required": false; }; }, {}, never, never, true, never>;
}
interface Person {
    name: string;
    hue?: number;
    src?: string;
}
declare class VspAvatarGroup {
    people: Person[];
    max: number;
    size: number;
    get shown(): Person[];
    get extra(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAvatarGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAvatarGroup, "vsp-avatar-group", never, { "people": { "alias": "people"; "required": false; }; "max": { "alias": "max"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspSegmented {
    value?: string;
    valueChange: EventEmitter<string>;
    options: string[];
    pick(o: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSegmented, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSegmented, "vsp-segmented", never, { "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class VspSpinner {
    size: 'sm' | 'md' | 'lg';
    label?: string;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSpinner, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSpinner, "vsp-spinner", never, { "size": { "alias": "size"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
}
type IconButtonVariant = 'ghost' | 'subtle' | 'danger';
declare class VspIconButton {
    label?: string;
    size: 'sm' | 'md' | 'lg';
    variant?: IconButtonVariant;
    loading: boolean;
    disabled: boolean;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspIconButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspIconButton, "vsp-icon-button", never, { "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class VspProgress {
    value: number;
    tone?: string;
    height: number;
    max: number;
    indeterminate: boolean;
    label?: string;
    get pct(): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspProgress, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspProgress, "vsp-progress", never, { "value": { "alias": "value"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "height": { "alias": "height"; "required": false; }; "max": { "alias": "max"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspSkeleton {
    w: string | number;
    h: string | number;
    r: number;
    px(v: string | number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSkeleton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSkeleton, "vsp-skeleton", never, { "w": { "alias": "w"; "required": false; }; "h": { "alias": "h"; "required": false; }; "r": { "alias": "r"; "required": false; }; }, {}, never, never, true, never>;
}

declare class VspCard {
    pad: boolean;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCard, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCard, "vsp-card", never, { "pad": { "alias": "pad"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class VspCardHead {
    title?: string;
    desc?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCardHead, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCardHead, "vsp-card-head", never, { "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; }, {}, never, ["[slot=right]"], true, never>;
}

type AlertTone = 'info' | 'pos' | 'warn' | 'neg';
declare class VspAlert {
    tone: AlertTone;
    title?: string;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAlert, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAlert, "vsp-alert", never, { "tone": { "alias": "tone"; "required": false; }; "title": { "alias": "title"; "required": false; }; }, {}, never, ["[slot=icon]", "*", "[slot=action]"], true, never>;
}

declare class VspField {
    label?: string;
    required: boolean;
    hint?: string;
    error?: string;
    htmlFor?: string;
    get hintCls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspField, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspField, "vsp-field", never, { "label": { "alias": "label"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hint": { "alias": "hint"; "required": false; }; "error": { "alias": "error"; "required": false; }; "htmlFor": { "alias": "htmlFor"; "required": false; }; }, {}, never, ["*"], true, never>;
}
declare class VspInput {
    value: string;
    valueChange: EventEmitter<string>;
    invalid: boolean;
    get cls(): string;
    onInput(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspInput, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspInput, "vsp-input", never, { "value": { "alias": "value"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
declare class VspTextarea {
    value: string;
    valueChange: EventEmitter<string>;
    onInput(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTextarea, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTextarea, "vsp-textarea", never, { "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class VspSwitch {
    checked: boolean;
    checkedChange: EventEmitter<boolean>;
    size?: 'sm';
    disabled: boolean;
    get cls(): string;
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSwitch, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSwitch, "vsp-switch", never, { "checked": { "alias": "checked"; "required": false; }; "size": { "alias": "size"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
}
declare class VspCheckbox {
    checked: boolean;
    checkedChange: EventEmitter<boolean>;
    label?: string;
    sub?: string;
    disabled: boolean;
    indeterminate: boolean;
    invalid: boolean;
    id?: string;
    get checkCls(): string;
    toggle(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCheckbox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCheckbox, "vsp-checkbox", never, { "checked": { "alias": "checked"; "required": false; }; "label": { "alias": "label"; "required": false; }; "sub": { "alias": "sub"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "indeterminate": { "alias": "indeterminate"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "checkedChange": "checkedChange"; }, never, never, true, never>;
}

type NativeSelectOption = string | {
    value: string;
    label: string;
    sub?: string;
    disabled?: boolean;
};
declare class VspRadio {
    checked: boolean;
    label?: string;
    sub?: string;
    name?: string;
    value?: string;
    disabled: boolean;
    select: EventEmitter<void>;
    get dotCls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspRadio, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspRadio, "vsp-radio", never, { "checked": { "alias": "checked"; "required": false; }; "label": { "alias": "label"; "required": false; }; "sub": { "alias": "sub"; "required": false; }; "name": { "alias": "name"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "select": "select"; }, never, never, true, never>;
}
declare class VspRadioGroup {
    value?: string;
    valueChange: EventEmitter<string>;
    options: NativeSelectOption[];
    name: string;
    disabled: boolean;
    orientation: 'vertical' | 'horizontal';
    val: (o: NativeSelectOption) => string;
    lbl: (o: NativeSelectOption) => string;
    subOf: (o: NativeSelectOption) => string | undefined;
    disOf(o: NativeSelectOption): boolean;
    pick(v: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspRadioGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspRadioGroup, "vsp-radio-group", never, { "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; "name": { "alias": "name"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
declare class VspSlider {
    value: number;
    valueChange: EventEmitter<number>;
    min: number;
    max: number;
    step: number;
    disabled: boolean;
    id?: string;
    ariaLabel?: string;
    onInput(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSlider, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSlider, "vsp-slider", never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
declare class VspNativeSelect {
    value?: string;
    valueChange: EventEmitter<string>;
    options: NativeSelectOption[];
    val: (o: NativeSelectOption) => string;
    lbl: (o: NativeSelectOption) => string;
    onChange(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspNativeSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspNativeSelect, "vsp-native-select", never, { "value": { "alias": "value"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

type TabItem = string | {
    value: string;
    label: string;
    count?: number;
    disabled?: boolean;
};
type BreadcrumbItem = string | {
    label: string;
    href?: string;
    icon?: string;
};
declare class VspTabs {
    tabs: TabItem[];
    value?: string;
    valueChange: EventEmitter<string>;
    id(t: TabItem): string;
    lbl(t: TabItem): string;
    cnt(t: TabItem): number | undefined;
    dis(t: TabItem): boolean | undefined;
    cls(t: TabItem): string;
    pick(v: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTabs, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTabs, "vsp-tabs", never, { "tabs": { "alias": "tabs"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, ["[slot=right]"], true, never>;
}
declare class VspBreadcrumb {
    items: BreadcrumbItem[];
    maxItems?: number;
    readonly ELL: {
        ellipsis: boolean;
    };
    get display(): unknown[];
    isEll(it: unknown): boolean;
    private obj;
    lbl(it: unknown): string;
    hrefOf(it: unknown): string | undefined;
    iconOf(it: unknown): string | undefined;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBreadcrumb, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBreadcrumb, "vsp-breadcrumb", never, { "items": { "alias": "items"; "required": false; }; "maxItems": { "alias": "maxItems"; "required": false; }; }, {}, never, never, true, never>;
}
interface PageItem {
    gap: boolean;
    n: number;
}
declare class VspPagination {
    page: number;
    pageChange: EventEmitter<number>;
    pages: number;
    get nums(): PageItem[];
    numCls(n: number): string;
    go(p: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspPagination, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspPagination, "vsp-pagination", never, { "page": { "alias": "page"; "required": false; }; "pages": { "alias": "pages"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
}
type StepStatus = 'done' | 'active' | 'pending' | 'error';
type StepperItem = string | {
    label: string;
    status?: StepStatus;
};
declare class VspStepper {
    steps: StepperItem[];
    current: number;
    onStepClick?: (i: number) => void;
    orientation: 'horizontal' | 'vertical';
    lbl(s: StepperItem): string;
    statusOf(i: number, s: StepperItem): StepStatus;
    barCls(i: number): string;
    stepCls(i: number, s: StepperItem): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspStepper, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspStepper, "vsp-stepper", never, { "steps": { "alias": "steps"; "required": false; }; "current": { "alias": "current"; "required": false; }; "onStepClick": { "alias": "onStepClick"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, {}, never, never, true, never>;
}

declare class VspCircularProgress {
    value: number;
    size: number;
    thickness: number;
    color: string;
    label?: string;
    get r(): number;
    get circ(): number;
    get offset(): number;
    get display(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCircularProgress, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCircularProgress, "vsp-circular-progress", never, { "value": { "alias": "value"; "required": false; }; "size": { "alias": "size"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "color": { "alias": "color"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspStat {
    label?: string;
    value?: string;
    delta?: string;
    deltaDir: 'up' | 'down';
    tone: string;
    get deltaCls(): string;
    get arrow(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspStat, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspStat, "vsp-stat", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "delta": { "alias": "delta"; "required": false; }; "deltaDir": { "alias": "deltaDir"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; }, {}, never, ["[slot=icon]"], true, never>;
}
type TimelineTone = 'pos' | 'neg' | 'warn' | 'info';
interface TimelineItem {
    title: string;
    time?: string;
    body?: string;
    tone?: TimelineTone;
    active?: boolean;
}
declare class VspTimeline {
    items: TimelineItem[];
    orientation: 'vertical' | 'horizontal';
    dotStyle(tone?: TimelineTone): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTimeline, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTimeline, "vsp-timeline", never, { "items": { "alias": "items"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspDescriptionList {
    items: [string, string][];
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDescriptionList, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDescriptionList, "vsp-description-list", never, { "items": { "alias": "items"; "required": false; }; }, {}, never, never, true, never>;
}

type BannerTone = 'info' | 'warn' | 'accent' | 'pos' | 'neg';
declare class VspBanner {
    tone: BannerTone;
    dismissible: boolean;
    dismiss: EventEmitter<void>;
    get cls(): string;
    get iconPath(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBanner, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBanner, "vsp-banner", never, { "tone": { "alias": "tone"; "required": false; }; "dismissible": { "alias": "dismissible"; "required": false; }; }, { "dismiss": "dismiss"; }, never, ["[slot=icon]", "*", "[slot=action]"], true, never>;
}
declare class VspEmptyState {
    title?: string;
    desc?: string;
    compact: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspEmptyState, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspEmptyState, "vsp-empty-state", never, { "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; "compact": { "alias": "compact"; "required": false; }; }, {}, never, ["[slot=icon]", "[slot=action]"], true, never>;
}
interface AccordionItem {
    title: string;
    body: string;
}
declare class VspAccordion implements OnInit {
    items: AccordionItem[];
    multiple: boolean;
    defaultOpen: number[];
    /** Controlled open indices. Omit for uncontrolled. */
    open?: number[];
    openChange: EventEmitter<number[]>;
    private internal;
    ngOnInit(): void;
    private get openSet();
    toggle(i: number): void;
    itemCls(i: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAccordion, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAccordion, "vsp-accordion", never, { "items": { "alias": "items"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, never, true, never>;
}

type Pt = [number, number];
declare class VspSparkline {
    data: number[];
    color: string;
    w: number;
    h: number;
    fill: boolean;
    gid: string;
    get pts(): Pt[];
    get d(): string;
    get areaD(): string;
    get last(): Pt;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSparkline, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSparkline, "vsp-sparkline", never, { "data": { "alias": "data"; "required": false; }; "color": { "alias": "color"; "required": false; }; "w": { "alias": "w"; "required": false; }; "h": { "alias": "h"; "required": false; }; "fill": { "alias": "fill"; "required": false; }; }, {}, never, never, true, never>;
}
interface DonutDatum {
    label: string;
    value: number;
    color: string;
}
declare class VspDonut {
    data: DonutDatum[];
    size: number;
    thickness: number;
    centerLabel?: string;
    valueFormat?: (n: number) => string;
    hover: number | null;
    fmt(n: number): string;
    get total(): number;
    get r(): number;
    get c(): number;
    get circ(): number;
    get segs(): {
        color: string;
        dash: string;
        offset: number;
    }[];
    pct(v: number): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDonut, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDonut, "vsp-donut", never, { "data": { "alias": "data"; "required": false; }; "size": { "alias": "size"; "required": false; }; "thickness": { "alias": "thickness"; "required": false; }; "centerLabel": { "alias": "centerLabel"; "required": false; }; "valueFormat": { "alias": "valueFormat"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspStatCard {
    label?: string;
    value?: string;
    delta?: string;
    deltaDir: 'up' | 'down';
    spark?: number[];
    sparkColor: string;
    get deltaCls(): string;
    get arrow(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspStatCard, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspStatCard, "vsp-stat-card", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "delta": { "alias": "delta"; "required": false; }; "deltaDir": { "alias": "deltaDir"; "required": false; }; "spark": { "alias": "spark"; "required": false; }; "sparkColor": { "alias": "sparkColor"; "required": false; }; }, {}, never, ["[slot=icon]"], true, never>;
}

declare class VspNumberStepper {
    value: number;
    valueChange: EventEmitter<number>;
    min?: number;
    max?: number;
    step: number;
    unit?: string;
    disabled: boolean;
    id?: string;
    set(v: number): void;
    onInput(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspNumberStepper, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspNumberStepper, "vsp-number-stepper", never, { "value": { "alias": "value"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
declare class VspCopyButton {
    text: string;
    label: string;
    size: string;
    done: boolean;
    get cls(): string;
    copy(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCopyButton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCopyButton, "vsp-copy-button", never, { "text": { "alias": "text"; "required": false; }; "label": { "alias": "label"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspInlineEdit {
    value: string;
    placeholder: string;
    save: EventEmitter<string>;
    editing: boolean;
    draft: string;
    start(): void;
    commit(): void;
    cancel(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspInlineEdit, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspInlineEdit, "vsp-inline-edit", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; }, { "save": "save"; }, never, never, true, never>;
}

interface TreeNodeData {
    id?: string;
    label: string;
    badge?: string;
    children?: TreeNodeData[];
}
declare class VspTree implements OnInit {
    data: TreeNodeData[];
    defaultExpanded: string[];
    /** Controlled expanded node ids. Omit for uncontrolled. */
    expandedInput?: string[];
    expandedChange: EventEmitter<string[]>;
    /** Controlled selected node id. Omit for uncontrolled. */
    selectedInput?: string | null;
    select: EventEmitter<string>;
    private internalExpanded;
    private internalSelected;
    ngOnInit(): void;
    get expandedSet(): Set<string>;
    get selectedId(): string | null;
    id(n: TreeNodeData): string;
    hasKids(n: TreeNodeData): boolean;
    rowCls(n: TreeNodeData): string;
    activate(n: TreeNodeData): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTree, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTree, "vsp-tree", never, { "data": { "alias": "data"; "required": false; }; "defaultExpanded": { "alias": "defaultExpanded"; "required": false; }; "expandedInput": { "alias": "expanded"; "required": false; }; "selectedInput": { "alias": "selected"; "required": false; }; }, { "expandedChange": "expandedChange"; "select": "select"; }, never, never, true, never>;
}

declare class VspOTPInput {
    length: number;
    value: string;
    disabled: boolean;
    invalid: boolean;
    valueChange: EventEmitter<string>;
    complete: EventEmitter<string>;
    inputs: QueryList<ElementRef<HTMLInputElement>>;
    get indices(): number[];
    private chars;
    private emit;
    set(i: number, raw: string): void;
    onPaste(i: number, e: ClipboardEvent): void;
    onKey(i: number, e: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspOTPInput, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspOTPInput, "vsp-otp-input", never, { "length": { "alias": "length"; "required": false; }; "value": { "alias": "value"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; }, { "valueChange": "valueChange"; "complete": "complete"; }, never, never, true, never>;
}

declare class VspAreaChart {
    series: number[][];
    labels?: string[];
    width: number;
    height: number;
    color: string;
    color2: string;
    dual: boolean;
    gid: string;
    padL: number;
    padB: number;
    padT: number;
    padR: number;
    get innerW(): number;
    get innerH(): number;
    get s0(): number[];
    get s1(): number[] | undefined;
    get max(): number;
    get rng(): number;
    sx(i: number, len: number): number;
    sy(v: number): number;
    showLabel(i: number): boolean;
    get ticks(): {
        y: number;
        label: string;
    }[];
    get lineEls(): {
        d: string;
        area: string | null;
        stroke: string;
        dash: string | null;
        opacity: number;
    }[];
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAreaChart, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAreaChart, "vsp-area-chart", never, { "series": { "alias": "series"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "color": { "alias": "color"; "required": false; }; "color2": { "alias": "color2"; "required": false; }; "dual": { "alias": "dual"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspBarChart {
    data: number[] | number[][];
    labels?: string[];
    width: number;
    height: number;
    color?: string;
    colors?: string[];
    seriesLabels?: string[];
    horizontal: boolean;
    stacked: boolean;
    valueFormat?: (n: number) => string;
    showValues: boolean;
    hover: number | null;
    padB: number;
    padT: number;
    padR: number;
    get series(): number[][];
    get nSeries(): number;
    get nCats(): number;
    get padL(): number;
    colorAt(s: number): string;
    fmt(n: number): string;
    dim(c: string): string;
    get max(): number;
    get valAxis(): number;
    get catAxis(): number;
    get band(): number;
    private rect;
    get bars(): {
        x: number;
        y: number;
        w: number;
        h: number;
        fill: string;
        i: number;
    }[];
    get gridEls(): {
        x1: number;
        x2: number;
        y1: number;
        y2: number;
        tx: number;
        ty: number;
        anchor: string;
        label: string;
    }[];
    get cats(): {
        i: number;
        hx: number;
        hy: number;
        hw: number;
        hh: number;
        label: string | undefined;
        lx: number;
        ly: number;
        anchor: string;
    }[];
    get tipLeft(): number;
    get tipTop(): number;
    get tipRows(): {
        color: string;
        label?: string;
        value: string;
    }[];
    get showLegend(): boolean;
    get legendItems(): {
        color: string;
        label: string;
    }[];
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBarChart, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBarChart, "vsp-bar-chart", never, { "data": { "alias": "data"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "color": { "alias": "color"; "required": false; }; "colors": { "alias": "colors"; "required": false; }; "seriesLabels": { "alias": "seriesLabels"; "required": false; }; "horizontal": { "alias": "horizontal"; "required": false; }; "stacked": { "alias": "stacked"; "required": false; }; "valueFormat": { "alias": "valueFormat"; "required": false; }; "showValues": { "alias": "showValues"; "required": false; }; }, {}, never, never, true, never>;
}

type DialogTone = 'pos' | 'neg' | 'warn' | 'info';
/**
 * A modal dialog. Renders in place — `.ui-overlay` is `position: fixed`, so as
 * long as the component lives inside `.vsp-root` the overlay covers the viewport
 * and inherits the theme tokens (no portal needed). Project content into the
 * default slot for the body, `slot="icon"` for the header icon, and
 * `slot="footer"` for the footer.
 */
declare class VspDialog {
    open: boolean;
    title?: string;
    desc?: string;
    maxWidth: number;
    tone?: DialogTone;
    closeOnOverlayClick: boolean;
    closeOnEsc: boolean;
    close: EventEmitter<void>;
    private cleanup;
    set panelRef(el: ElementRef<HTMLElement> | undefined);
    get color(): string;
    onEsc(): void;
    onBackdrop(e: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDialog, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDialog, "vsp-dialog", never, { "open": { "alias": "open"; "required": false; }; "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "tone": { "alias": "tone"; "required": false; }; "closeOnOverlayClick": { "alias": "closeOnOverlayClick"; "required": false; }; "closeOnEsc": { "alias": "closeOnEsc"; "required": false; }; }, { "close": "close"; }, never, ["[slot=icon]", "*", "[slot=footer]"], true, never>;
}
/** A side drawer. Like `vsp-dialog`, renders in place inside `.vsp-root`. */
declare class VspSheet {
    open: boolean;
    title?: string;
    desc?: string;
    side: 'right' | 'left' | 'top' | 'bottom';
    closeOnOverlayClick: boolean;
    closeOnEsc: boolean;
    close: EventEmitter<void>;
    private cleanup;
    set panelRef(el: ElementRef<HTMLElement> | undefined);
    onEsc(): void;
    onBackdrop(e: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSheet, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSheet, "vsp-sheet", never, { "open": { "alias": "open"; "required": false; }; "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; "side": { "alias": "side"; "required": false; }; "closeOnOverlayClick": { "alias": "closeOnOverlayClick"; "required": false; }; "closeOnEsc": { "alias": "closeOnEsc"; "required": false; }; }, { "close": "close"; }, never, ["[slot=icon]", "*", "[slot=footer]"], true, never>;
}

type AnchoredAlign = 'start' | 'end';
/** Roving arrow-key focus between sibling menu items (one level). */
declare function menuNav(e: KeyboardEvent): void;
/**
 * Positioning base for menus and popovers: anchors a layer to a trigger. The
 * layer is `position: fixed`, so it renders in place (inside `.vsp-root`) and is
 * positioned against the trigger's viewport rect. Click-outside and Escape close
 * it. Project the trigger with `slot="trigger"`; the default slot is the layer.
 */
declare class VspAnchored {
    align: AnchoredAlign;
    width?: number;
    layerClass: string;
    /** Controlled open state. Leave unset for uncontrolled. */
    openInput?: boolean;
    openChange: EventEmitter<boolean>;
    trig: ElementRef<HTMLElement>;
    layer?: ElementRef<HTMLElement>;
    internalOpen: boolean;
    rect: DOMRect | null;
    layerSize: {
        w: number;
        h: number;
    } | null;
    get isOpen(): boolean;
    private setOpen;
    toggle(): void;
    close(): void;
    place(): void;
    private measure;
    get layerStyle(): string;
    onDoc(e: MouseEvent): void;
    onEsc(): void;
    onResize(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAnchored, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAnchored, "vsp-anchored", never, { "align": { "alias": "align"; "required": false; }; "width": { "alias": "width"; "required": false; }; "layerClass": { "alias": "layerClass"; "required": false; }; "openInput": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["[slot=trigger]", "*"], true, never>;
}
interface MenuItem {
    label?: string;
    kbd?: string;
    /** Optional leading icon name (see `vsp-icon`). */
    icon?: string;
    danger?: boolean;
    heading?: boolean;
    sep?: boolean;
    disabled?: boolean;
    /** Render as a checkable item — shows a tick and keeps the menu open on select. */
    type?: 'checkbox' | 'radio';
    checked?: boolean;
    /** Nested items — renders a submenu that flies out to the side. */
    items?: MenuItem[];
    onClick?: () => void;
}
declare class VspMenuItems {
    items: MenuItem[];
    close: () => void;
    nav: typeof menuNav;
    role(it: MenuItem): string;
    pick(it: MenuItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspMenuItems, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspMenuItems, "vsp-menu-items", never, { "items": { "alias": "items"; "required": false; }; "close": { "alias": "close"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspSubMenuItem {
    item: MenuItem;
    close: () => void;
    btn?: ElementRef<HTMLElement>;
    open: boolean;
    rect: DOMRect | null;
    private timer;
    private cancel;
    openNow(): void;
    closeSoon(): void;
    onKey(e: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSubMenuItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSubMenuItem, "vsp-sub-menu-item", never, { "item": { "alias": "item"; "required": false; }; "close": { "alias": "close"; "required": false; }; }, {}, never, never, true, never>;
}
declare class VspDropdownMenu {
    items: MenuItem[];
    align: AnchoredAlign;
    width?: number;
    open?: boolean;
    openChange: EventEmitter<boolean>;
    anchored?: VspAnchored;
    closeFn: () => void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDropdownMenu, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDropdownMenu, "vsp-dropdown-menu", never, { "items": { "alias": "items"; "required": false; }; "align": { "alias": "align"; "required": false; }; "width": { "alias": "width"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["[slot=trigger]"], true, never>;
}
declare class VspPopover {
    align: AnchoredAlign;
    width: number;
    open?: boolean;
    openChange: EventEmitter<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspPopover, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspPopover, "vsp-popover", never, { "align": { "alias": "align"; "required": false; }; "width": { "alias": "width"; "required": false; }; "open": { "alias": "open"; "required": false; }; }, { "openChange": "openChange"; }, never, ["[slot=trigger]", "*"], true, never>;
}

declare class VspTooltip {
    label?: string;
    side: 'top' | 'bottom' | 'left' | 'right';
    delay: number;
    disabled: boolean;
    el: ElementRef<HTMLElement>;
    show: boolean;
    pos: {
        x: number;
        y: number;
    };
    private timer;
    private static readonly TRANSFORM;
    get transform(): string;
    private place;
    enter(): void;
    leave(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTooltip, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTooltip, "vsp-tooltip", never, { "label": { "alias": "label"; "required": false; }; "side": { "alias": "side"; "required": false; }; "delay": { "alias": "delay"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*"], true, never>;
}

type ToastTone = 'info' | 'pos' | 'neg' | 'warn';
interface ToastAction {
    label: string;
    onClick: () => void;
}
type ToastPosition = 'top-left' | 'top' | 'top-right' | 'bottom-left' | 'bottom' | 'bottom-right';
interface ToastOptions {
    title?: string;
    body?: string;
    tone?: ToastTone;
    /** Auto-dismiss after this many ms (default 3600). Pass `Infinity` to persist. */
    duration?: number;
    action?: ToastAction;
}
interface ToastItem extends ToastOptions {
    id: string;
}
/** Show a toast. Requires a `<vsp-toast-host />` mounted inside your `.vsp-root`. */
declare function toast(opts: ToastOptions | string): void;
declare class VspToastHost {
    position: ToastPosition;
    toasts: i0.Signal<ToastItem[]>;
    icon(tone?: ToastTone): string;
    dismiss(id: string): void;
    runAction(t: ToastItem): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspToastHost, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspToastHost, "vsp-toast-host", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, never, true, never>;
}

interface CommandItem {
    label: string;
    meta?: string;
    keywords?: string;
    /** Optional leading icon as an SVG path `d` string. */
    icon?: string;
    onRun?: () => void;
}
interface CommandGroup {
    label: string;
    items: CommandItem[];
}
type FlatCmd = CommandItem & {
    group: string;
    idx: number;
};
/**
 * A ⌘K-style command palette. Renders in place — `.ui-overlay` is
 * `position: fixed`, so as long as the component lives inside `.vsp-root` it
 * covers the viewport and inherits the theme tokens (no portal needed).
 */
declare class VspCommandPalette implements OnChanges {
    open: boolean;
    groups: CommandGroup[];
    close: EventEmitter<void>;
    input?: ElementRef<HTMLInputElement>;
    q: string;
    active: number;
    ngOnChanges(changes: SimpleChanges): void;
    get flat(): FlatCmd[];
    get groupOrder(): string[];
    itemsOf(g: string): FlatCmd[];
    onInput(e: Event): void;
    run(it: FlatCmd | undefined): void;
    onEsc(): void;
    onBackdrop(e: MouseEvent): void;
    onKey(e: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCommandPalette, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCommandPalette, "vsp-command-palette", never, { "open": { "alias": "open"; "required": false; }; "groups": { "alias": "groups"; "required": false; }; }, { "close": "close"; }, never, never, true, never>;
}

type SelectValue = string | number;
interface SelectOption {
    value: SelectValue;
    label: string;
    /** Optional color swatch shown before the label. */
    swatch?: string;
}
type SelectOptionInput = SelectValue | SelectOption;
/**
 * Floating panel that tracks its trigger. Renders in place — `.ui-menu` is
 * positioned `fixed` from the anchor's rect, so it escapes overflow as long as
 * the component lives inside `.vsp-root`. Project the panel body as content.
 */
declare class VspSelPanel implements OnChanges, OnDestroy {
    open: boolean;
    anchor: HTMLElement | null;
    width?: number;
    menuClass: string;
    /** Hug the content (auto width, no padding/max-height) — used by the date pickers. */
    auto: boolean;
    close: EventEmitter<void>;
    panel?: ElementRef<HTMLElement>;
    rect: DOMRect | null;
    private cleanup;
    get maxH(): number;
    private place;
    ngOnChanges(c: SimpleChanges): void;
    private activate;
    private deactivate;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSelPanel, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSelPanel, "vsp-sel-panel", never, { "open": { "alias": "open"; "required": false; }; "anchor": { "alias": "anchor"; "required": false; }; "width": { "alias": "width"; "required": false; }; "menuClass": { "alias": "menuClass"; "required": false; }; "auto": { "alias": "auto"; "required": false; }; }, { "close": "close"; }, never, ["*"], true, never>;
}
declare class VspComboList implements AfterViewInit {
    q: string;
    items: SelectOption[];
    activeIdx: number;
    isSel: (o: SelectOption) => boolean;
    searchPlaceholder?: string;
    loading: boolean;
    emptyText?: string;
    qChange: EventEmitter<string>;
    activeIdxChange: EventEmitter<number>;
    pick: EventEmitter<SelectOption>;
    search?: ElementRef<HTMLInputElement>;
    ngAfterViewInit(): void;
    onInput(e: Event): void;
    onKey(e: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspComboList, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspComboList, "vsp-combo-list", never, { "q": { "alias": "q"; "required": false; }; "items": { "alias": "items"; "required": false; }; "activeIdx": { "alias": "activeIdx"; "required": false; }; "isSel": { "alias": "isSel"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; }, { "qChange": "qChange"; "activeIdxChange": "activeIdxChange"; "pick": "pick"; }, never, ["[footer]"], true, never>;
}
declare class VspSelect {
    options: SelectOptionInput[];
    value?: SelectValue;
    valueChange: EventEmitter<SelectValue>;
    placeholder: string;
    disabled: boolean;
    invalid: boolean;
    emptyText?: string;
    id?: string;
    name?: string;
    searchable?: boolean;
    open: boolean;
    q: string;
    active: number;
    get opts(): SelectOption[];
    get cur(): SelectValue | undefined;
    get sel(): SelectOption | undefined;
    get useSearch(): boolean;
    get items(): SelectOption[];
    isSelFn: (o: SelectOption) => boolean;
    sameVal(o: SelectOption): boolean;
    choose(o: SelectOption): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSelect, "vsp-select", never, { "options": { "alias": "options"; "required": false; }; "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "searchable": { "alias": "searchable"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
declare class VspCombobox {
    options: SelectOptionInput[];
    value: SelectValue | null;
    valueChange: EventEmitter<SelectValue>;
    placeholder: string;
    searchPlaceholder?: string;
    clearable: boolean;
    disabled: boolean;
    invalid: boolean;
    loading: boolean;
    emptyText?: string;
    id?: string;
    name?: string;
    creatable: boolean;
    created: EventEmitter<string>;
    open: boolean;
    q: string;
    active: number;
    get canCreate(): boolean;
    create(): void;
    get opts(): SelectOption[];
    get sel(): SelectOption | undefined;
    get items(): SelectOption[];
    isSelFn: (o: SelectOption) => boolean;
    set(v: SelectValue | null): void;
    clear(e: Event): void;
    pick(o: SelectOption): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCombobox, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCombobox, "vsp-combobox", never, { "options": { "alias": "options"; "required": false; }; "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "clearable": { "alias": "clearable"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; "creatable": { "alias": "creatable"; "required": false; }; }, { "valueChange": "valueChange"; "created": "created"; }, never, never, true, never>;
}
declare class VspMultiSelect {
    options: SelectOptionInput[];
    value: SelectValue[];
    valueChange: EventEmitter<SelectValue[]>;
    placeholder: string;
    searchPlaceholder?: string;
    max?: number;
    disabled: boolean;
    invalid: boolean;
    loading: boolean;
    emptyText?: string;
    id?: string;
    name?: string;
    open: boolean;
    q: string;
    active: number;
    get opts(): SelectOption[];
    get items(): SelectOption[];
    get selOpts(): SelectOption[];
    has(v: SelectValue): boolean;
    isSelFn: (o: SelectOption) => boolean;
    set(next: SelectValue[]): void;
    toggle(o: SelectOption): void;
    remove(o: SelectOption): void;
    toggleOpen(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspMultiSelect, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspMultiSelect, "vsp-multi-select", never, { "options": { "alias": "options"; "required": false; }; "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchPlaceholder": { "alias": "searchPlaceholder"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "emptyText": { "alias": "emptyText"; "required": false; }; "id": { "alias": "id"; "required": false; }; "name": { "alias": "name"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
declare class VspTokenInput {
    value: string[];
    valueChange: EventEmitter<string[]>;
    placeholder: string;
    disabled: boolean;
    invalid: boolean;
    max?: number;
    id?: string;
    root?: ElementRef<HTMLElement>;
    draft: string;
    get full(): boolean;
    set(next: string[]): void;
    add(): void;
    remove(t: string): void;
    focusInput(): void;
    onKey(e: KeyboardEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTokenInput, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTokenInput, "vsp-token-input", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "invalid": { "alias": "invalid"; "required": false; }; "max": { "alias": "max"; "required": false; }; "id": { "alias": "id"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

declare class VspFileDropzone {
    hint: string;
    accept?: string;
    multiple: boolean;
    maxSize?: number;
    maxFiles?: number;
    disabled: boolean;
    files: EventEmitter<File[]>;
    reject: EventEmitter<File[]>;
    input?: ElementRef<HTMLInputElement>;
    drag: boolean;
    private take;
    onDragOver(e: DragEvent): void;
    onDrop(e: DragEvent): void;
    onChange(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspFileDropzone, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspFileDropzone, "vsp-file-dropzone", never, { "hint": { "alias": "hint"; "required": false; }; "accept": { "alias": "accept"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "maxFiles": { "alias": "maxFiles"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "files": "files"; "reject": "reject"; }, never, never, true, never>;
}

/** Format a date like "Jan 5, 2026". */
declare const fmtDate: (d: Date | null | undefined) => string;
/**
 * Flexible date matcher used by the pickers' `disabled` input. Accepts a `Date`,
 * `Date[]`, `{ from, to }`, `{ before }`, `{ after }`, `{ dayOfWeek: [0,6] }`, a
 * `(date) => boolean` predicate, or an array of any of these (any match wins).
 */
type DateMatcher = Date | Date[] | {
    from: Date;
    to: Date;
} | {
    before: Date;
} | {
    after: Date;
} | {
    dayOfWeek: number[];
} | ((date: Date) => boolean);
/** True when `d` satisfies the matcher (or any matcher in the array). */
declare function matchesDate(d: Date, matcher?: DateMatcher | DateMatcher[]): boolean;
interface GridDay {
    dt: Date;
    muted?: boolean;
}
interface MonthView {
    m: number;
    y: number;
}
type RangeEdge = 'start' | 'end' | false;
interface DateRange {
    start: Date | null;
    end: Date | null;
}
/** A named shortcut shown in the range picker's preset rail. */
interface RangePreset {
    label: string;
    range: DateRange;
}
declare class VspCalendar {
    private readonly cdr;
    view: MonthView;
    viewChange: EventEmitter<MonthView>;
    isSelected: (d: Date) => boolean;
    isInRange?: (d: Date) => boolean;
    isRangeEnd?: (d: Date) => RangeEdge;
    isDisabled?: (d: Date) => boolean;
    min?: Date;
    max?: Date;
    pick: EventEmitter<Date>;
    dow: string[];
    months: string[];
    today: Date;
    strip: (d: Date) => Date;
    get days(): GridDay[];
    private get minD();
    private get maxD();
    get prevDisabled(): boolean;
    get nextDisabled(): boolean;
    dayDisabled: (dt: Date) => boolean;
    nav(delta: number): void;
    dayClass(dt: Date, muted?: boolean): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspCalendar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspCalendar, "vsp-calendar", never, { "view": { "alias": "view"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "isInRange": { "alias": "isInRange"; "required": false; }; "isRangeEnd": { "alias": "isRangeEnd"; "required": false; }; "isDisabled": { "alias": "isDisabled"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; }, { "viewChange": "viewChange"; "pick": "pick"; }, never, never, true, never>;
}
declare class VspDatePicker implements OnChanges {
    value: Date | null;
    valueChange: EventEmitter<Date>;
    placeholder: string;
    min?: Date;
    max?: Date;
    disabled?: DateMatcher | DateMatcher[];
    multiple: boolean;
    values: Date[];
    valuesChange: EventEmitter<Date[]>;
    open: boolean;
    view: MonthView;
    fmt: (d: Date | null | undefined) => string;
    private syncedTime?;
    constructor();
    ngOnChanges(): void;
    get label(): string;
    get empty(): boolean;
    isDisabledFn: (d: Date) => boolean;
    isSelectedFn: (d: Date) => boolean;
    choose(d: Date): void;
    clearAll(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDatePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDatePicker, "vsp-date-picker", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "multiple": { "alias": "multiple"; "required": false; }; "values": { "alias": "values"; "required": false; }; }, { "valueChange": "valueChange"; "valuesChange": "valuesChange"; }, never, never, true, never>;
}
declare class VspDateRangePicker {
    value: DateRange;
    valueChange: EventEmitter<DateRange>;
    placeholder: string;
    min?: Date;
    max?: Date;
    disabled?: DateMatcher | DateMatcher[];
    minNights?: number;
    maxNights?: number;
    presets?: RangePreset[];
    open: boolean;
    view: MonthView;
    constructor();
    set(r: DateRange): void;
    pick(d: Date): void;
    isDisabledFn: (d: Date) => boolean;
    isSelectedFn: (d: Date) => boolean;
    isInRangeFn: (d: Date) => boolean;
    isRangeEndFn: (d: Date) => RangeEdge;
    isPresetActive(p: RangePreset): boolean;
    get label(): string;
    get footLabel(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspDateRangePicker, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspDateRangePicker, "vsp-date-range-picker", never, { "value": { "alias": "value"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "minNights": { "alias": "minNights"; "required": false; }; "maxNights": { "alias": "maxNights"; "required": false; }; "presets": { "alias": "presets"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

type EventTone = 'info' | 'success' | 'warning' | 'danger' | 'violet';
interface CalendarEvent {
    id?: string;
    /** Day of the month (1–31). */
    d: number;
    title: string;
    tone: EventTone;
    /** Display time, e.g. `"10:00"` or `"All day"`. */
    time: string;
    /** Hour (8–18) used to place the event in the week grid. */
    hour?: number;
}
interface InternalEvent extends CalendarEvent {
    id: string;
    hour: number;
}
interface Draft {
    days: number[];
    hour: number;
    title: string;
    tone: EventTone;
    time: string;
}
type View = 'month' | 'week' | 'agenda';
interface Cell {
    day: number;
    muted?: boolean;
}
/**
 * A month / week / agenda calendar with click-and-drag day selection and an
 * inline "new event" dialog. Events are kept in local state; `change` reports
 * every change so a host can persist them.
 */
declare class VspEventCalendar {
    initialEvents: CalendarEvent[];
    change: EventEmitter<CalendarEvent[]>;
    today: Date;
    view: View;
    vm: {
        m: number;
        y: number;
    };
    events: InternalEvent[];
    sel: {
        a: number;
        b: number;
    } | null;
    dragging: boolean;
    add: Draft | null;
    months: string[];
    dowFull: string[];
    toneOptions: {
        value: string;
        label: string;
    }[];
    hours: number[];
    constructor();
    tone(t: EventTone): string;
    bg(t: EventTone, pct: number): string;
    pad(h: number): string;
    cap(v: View): string;
    setView(v: string): void;
    goToday(): void;
    private commit;
    nav(delta: number): void;
    openAdd(days: number[], hour?: number): void;
    saveAdd(): void;
    slotClick(d: Date, h: number): void;
    get evByDay(): Record<number, InternalEvent[]>;
    get cells(): Cell[];
    get weekDays(): Date[];
    get agendaDays(): number[];
    get dialogDesc(): string;
    evsFor(c: Cell): InternalEvent[];
    apptAt(d: Date, h: number): InternalEvent | undefined;
    sortedDay(day: number): InternalEvent[];
    dowOf(day: number): number;
    isToday(d: number, muted?: boolean): boolean;
    inSel(d: number): boolean;
    cellClass(c: Cell): string;
    onLeave(): void;
    cellDown(c: Cell): void;
    cellEnter(c: Cell): void;
    cellUp(c: Cell): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspEventCalendar, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspEventCalendar, "vsp-event-calendar", never, { "initialEvents": { "alias": "initialEvents"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

/** Inline icon by name — keeps the Angular wrapper free of the icons package. */
declare class VspIcon {
    name: string;
    size: number;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspIcon, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspIcon, "vsp-icon", never, { "name": { "alias": "name"; "required": false; }; "size": { "alias": "size"; "required": false; }; }, {}, never, never, true, never>;
}

/** A labelled row (title + optional description) with a trailing control slot. */
declare class VspSettingRow {
    title?: string;
    desc?: string;
    last: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSettingRow, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSettingRow, "vsp-setting-row", never, { "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; "last": { "alias": "last"; "required": false; }; }, {}, never, ["*"], true, never>;
}
type VerticalTabItem = string | {
    value: string;
    label: string;
    icon?: string;
    badge?: string | number;
};
/** Vertical tab strip — a settings-style left rail. */
declare class VspVerticalTabs {
    tabs: VerticalTabItem[];
    value?: string;
    valueChange: EventEmitter<string>;
    id(t: VerticalTabItem): string;
    lbl(t: VerticalTabItem): string;
    ico(t: VerticalTabItem): string | undefined;
    bdg(t: VerticalTabItem): string | number | undefined;
    cls(t: VerticalTabItem): string;
    pick(v: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspVerticalTabs, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspVerticalTabs, "vsp-vertical-tabs", never, { "tabs": { "alias": "tabs"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}
/** A sidebar nav row — renders as an `<a>` when `href` is set, else a `<button>`. */
declare class VspNavItem {
    icon?: string;
    label?: string;
    active: boolean;
    badge?: string | number;
    sub: boolean;
    href?: string;
    disabled: boolean;
    get cls(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspNavItem, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspNavItem, "vsp-nav-item", never, { "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "active": { "alias": "active"; "required": false; }; "badge": { "alias": "badge"; "required": false; }; "sub": { "alias": "sub"; "required": false; }; "href": { "alias": "href"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, {}, never, ["*", "*"], true, never>;
}
/** A collapsible sidebar group; nested `vsp-nav-item`s project into the body. */
declare class VspNavGroup {
    icon?: string;
    label?: string;
    set defaultOpen(v: boolean);
    open: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspNavGroup, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspNavGroup, "vsp-nav-group", never, { "icon": { "alias": "icon"; "required": false; }; "label": { "alias": "label"; "required": false; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; }; }, {}, never, ["*"], true, never>;
}
/** Text input wrapped with an optional leading icon, prefix, and trailing unit. */
declare class VspInputAffix {
    value: string;
    valueChange: EventEmitter<string>;
    leadingIcon?: string;
    prefix?: string;
    unit?: string;
    wrapClass?: string;
    placeholder?: string;
    type: string;
    disabled: boolean;
    /** Common pass-through input attributes (React spreads the full set). */
    name?: string;
    inputId?: string;
    inputmode?: string;
    autocomplete?: string;
    min?: string | number;
    max?: string | number;
    step?: string | number;
    readonly: boolean;
    required: boolean;
    ariaLabel?: string;
    onInput(e: Event): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspInputAffix, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspInputAffix, "vsp-input-affix", never, { "value": { "alias": "value"; "required": false; }; "leadingIcon": { "alias": "leadingIcon"; "required": false; }; "prefix": { "alias": "prefix"; "required": false; }; "unit": { "alias": "unit"; "required": false; }; "wrapClass": { "alias": "wrapClass"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "type": { "alias": "type"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "name": { "alias": "name"; "required": false; }; "inputId": { "alias": "inputId"; "required": false; }; "inputmode": { "alias": "inputmode"; "required": false; }; "autocomplete": { "alias": "autocomplete"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "step": { "alias": "step"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "required": { "alias": "required"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
}

/** A stack of shimmer rows shown while a block's data is loading. */
declare class VspBlockSkeleton {
    rows: number;
    get rowList(): number[];
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBlockSkeleton, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBlockSkeleton, "vsp-block-skeleton", never, { "rows": { "alias": "rows"; "required": false; }; }, {}, never, never, true, never>;
}
/** Default empty placeholder; overridden by a projected `[slot=empty]` node. */
declare class VspBlockEmpty {
    title: string;
    desc?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBlockEmpty, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBlockEmpty, "vsp-block-empty", never, { "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; }, {}, never, never, true, never>;
}

/** A titled section wrapping its content in a Vespera `card`. */
declare class VspBlock {
    title?: string;
    desc?: string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspBlock, "vsp-block", never, { "title": { "alias": "title"; "required": false; }; "desc": { "alias": "desc"; "required": false; }; }, {}, never, ["*"], true, never>;
}
type ServiceStatus = 'operational' | 'degraded' | 'maintenance' | 'down';
interface Service {
    name: string;
    status: ServiceStatus;
    uptime: number;
}
/** Live service health with 30-day uptime bars. */
declare class VspSystemStatusBlock {
    services: Service[];
    loading: boolean;
    bars: number[];
    get allOk(): boolean;
    get accent(): string;
    tone(s: ServiceStatus): BadgeTone;
    isBad(s: Service, i: number): boolean;
    barBg(s: Service, i: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspSystemStatusBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspSystemStatusBlock, "vsp-system-status-block", never, { "services": { "alias": "services"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[slot=empty]"], true, never>;
}
interface AuditEntry {
    who: string;
    action: string;
    tag: string;
    time: string;
    /** Icon name (see `vsp-icon`). */
    icon: string;
}
/** A chronological trail of privileged actions, as a timeline. */
declare class VspAuditLogBlock {
    entries: AuditEntry[];
    loading: boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspAuditLogBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspAuditLogBlock, "vsp-audit-log-block", never, { "entries": { "alias": "entries"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[slot=empty]"], true, never>;
}

type OrderColumn = 'customer' | 'item' | 'status' | 'amount';
type OrderState = 'fulfilled' | 'processing' | 'pending' | 'refunded';
interface Order {
    id: string;
    company: string;
    hue: number;
    item: string;
    state: OrderState;
    amount: number;
}
/** Operational table: tab filters, bulk selection, status badges, row menu. */
declare class VspOrdersBlock {
    orders: Order[];
    columns: OrderColumn[];
    loading: boolean;
    tab: string;
    sel: Set<string>;
    rowMenu: MenuItem[];
    col(c: OrderColumn): boolean;
    get tabs(): ({
        value: string;
        label: string;
        count: number;
    } | {
        value: string;
        label: string;
        count?: undefined;
    })[];
    get rows(): Order[];
    get allSel(): boolean;
    orderTone(s: OrderState): BadgeTone;
    toggleAll(): void;
    toggle(id: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspOrdersBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspOrdersBlock, "vsp-orders-block", never, { "orders": { "alias": "orders"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[slot=empty]"], true, never>;
}
interface TeamMember {
    id: number;
    name: string;
    email: string;
    hue: number;
    role: string;
}
/** Member list with inline role selects and a per-row action menu. */
declare class VspTeamRolesBlock {
    members: TeamMember[];
    loading: boolean;
    memberMenu: MenuItem[];
    roleOptions: string[];
    setRole(id: number, role: string | number | null): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspTeamRolesBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspTeamRolesBlock, "vsp-team-roles-block", never, { "members": { "alias": "members"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[slot=empty]"], true, never>;
}
interface ApiKey {
    id: number;
    name: string;
    token: string;
    /** Full secret shown when revealed. */
    secret: string;
    created: string;
    last: string;
}
/** Reveal, copy, and revoke API credentials; secrets stay masked by default. */
declare class VspApiKeysBlock {
    keys: ApiKey[];
    loading: boolean;
    revealed: Set<number>;
    toggleReveal(id: number): void;
    created(): void;
    copied(): void;
    revoke(id: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspApiKeysBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspApiKeysBlock, "vsp-api-keys-block", never, { "keys": { "alias": "keys"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, {}, never, ["[slot=empty]"], true, never>;
}

interface KanbanCard {
    id: string;
    title: string;
    tag: string;
    tone: BadgeTone;
}
interface KanbanColumn {
    name: string;
    /** CSS colour for the column's status dot. */
    tone: string;
    cards: KanbanCard[];
}
interface DragState {
    card: KanbanCard;
    from: number;
    origIndex: number;
    w: number;
    offX: number;
    offY: number;
}
interface DropTarget {
    col: number;
    index: number;
}
/** A lightweight kanban — drag cards to reorder or move between columns. */
declare class VspKanbanBlock {
    columns: KanbanColumn[];
    change: EventEmitter<KanbanColumn[]>;
    colEls: QueryList<ElementRef<HTMLElement>>;
    cols: KanbanColumn[];
    drag: DragState | null;
    pt: {
        x: number;
        y: number;
    };
    target: DropTarget | null;
    private dragData;
    private targetData;
    ngOnInit(): void;
    items(col: KanbanColumn): KanbanCard[];
    showPh(ci: number): boolean;
    startDrag(e: PointerEvent, card: KanbanCard, ci: number): void;
    private onMove;
    private onUp;
    static ɵfac: i0.ɵɵFactoryDeclaration<VspKanbanBlock, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<VspKanbanBlock, "vsp-kanban-block", never, { "columns": { "alias": "columns"; "required": false; }; }, { "change": "change"; }, never, never, true, never>;
}

export { VspAccordion, VspAlert, VspAnchored, VspApiKeysBlock, VspAreaChart, VspAuditLogBlock, VspAvatar, VspAvatarGroup, VspBadge, VspBanner, VspBarChart, VspBlock, VspBlockEmpty, VspBlockSkeleton, VspBreadcrumb, VspButton, VspCalendar, VspCard, VspCardHead, VspCheckbox, VspCircularProgress, VspComboList, VspCombobox, VspCommandPalette, VspCopyButton, VspDatePicker, VspDateRangePicker, VspDescriptionList, VspDialog, VspDivider, VspDonut, VspDropdownMenu, VspEmptyState, VspEventCalendar, VspField, VspFileDropzone, VspIcon, VspIconButton, VspInlineEdit, VspInput, VspInputAffix, VspKanbanBlock, VspKbd, VspMenuItems, VspMultiSelect, VspNativeSelect, VspNavGroup, VspNavItem, VspNumberStepper, VspOTPInput, VspOrdersBlock, VspPagination, VspPopover, VspProgress, VspRadio, VspRadioGroup, VspSegmented, VspSelPanel, VspSelect, VspSettingRow, VspSheet, VspSkeleton, VspSlider, VspSparkline, VspSpinner, VspStat, VspStatCard, VspStepper, VspSubMenuItem, VspSwitch, VspSystemStatusBlock, VspTabs, VspTag, VspTeamRolesBlock, VspTextarea, VspTimeline, VspToastHost, VspTokenInput, VspTooltip, VspTree, VspVerticalTabs, fmtDate, matchesDate, toast };
export type { AccordionItem, AlertTone, AnchoredAlign, ApiKey, AuditEntry, AvatarStatus, BadgeTone, BannerTone, BreadcrumbItem, ButtonVariant, CalendarEvent, CommandGroup, CommandItem, DateMatcher, DateRange, DialogTone, DonutDatum, EventTone, IconButtonVariant, KanbanCard, KanbanColumn, MenuItem, MonthView, NativeSelectOption, Order, OrderColumn, OrderState, Person, RangeEdge, RangePreset, SelectOption, SelectOptionInput, SelectValue, Service, ServiceStatus, StepStatus, StepperItem, TabItem, TeamMember, TimelineItem, TimelineTone, ToastAction, ToastOptions, ToastPosition, ToastTone, TreeNodeData, VerticalTabItem };