@uipath/apollo-vertex 0.0.0-stage → 0.1.0

package/dist/registry/charts-core/util/format/bin-label.js

@@ -0,0 +1,27 @@
+import { DateTime, Interval } from "luxon";
+import { assert } from "../../../../lib/asserts/assert.js";
+import { assertDefined } from "../../../../lib/asserts/assert-defined.js";
+import { adaptiveBinFormatting } from "../binning/adaptive-bin-formatting.js";
+import { binLabelFormatSetting } from "./bin-label-format-setting.js";
+import { format } from "./format.js";
+const binLabel = ({ locale, bin, type, chartRange, isCompact = false })=>{
+    const { start, end } = bin;
+    if ("datetime" === type && isCompact) {
+        assert(start instanceof DateTime, "Min must be a DateTime");
+        assert(end instanceof DateTime, "Max must be a DateTime");
+        const interval = Interval.fromDateTimes(start, end);
+        return adaptiveBinFormatting(locale, interval, assertDefined(chartRange, "Chart range is required"));
+    }
+    const binStartSettings = binLabelFormatSetting({
+        value: start,
+        type,
+        isCompact
+    });
+    const binEndSettings = binLabelFormatSetting({
+        value: end,
+        type,
+        isCompact
+    });
+    return isCompact ? format(locale, start, type, binStartSettings) : `${format(locale, start, type, binStartSettings)} - ${format(locale, end, type, binEndSettings)}`;
+};
+export { binLabel };

package/dist/registry/charts-core/util/format/compute-duration-units.d.ts

@@ -0,0 +1,3 @@
+import type { Duration } from "luxon";
+import type { DurationUnit } from "./duration-unit";
+export declare const computeDurationUnits: (value: Duration, units?: DurationUnit[]) => DurationUnit[];

package/dist/registry/charts-core/util/format/compute-duration-units.js

@@ -0,0 +1,16 @@
+import { highestDurationUnit } from "./highest-duration-unit.js";
+const computeDurationUnits = (value, units = [])=>{
+    const isNegative = value.shiftTo("seconds").seconds < 0;
+    const absValue = isNegative ? value.negate() : value;
+    const highestUnit = highestDurationUnit(absValue);
+    const valueLeft = absValue.minus({
+        [highestUnit]: Math.floor(absValue.shiftTo(highestUnit).get(highestUnit))
+    }).normalize();
+    const newUnits = [
+        ...units,
+        highestUnit
+    ];
+    if (valueLeft.as("seconds") < 1) return newUnits;
+    return computeDurationUnits(valueLeft, newUnits);
+};
+export { computeDurationUnits };

package/dist/registry/charts-core/util/format/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const NULL_STRING = "NULL";
+export declare const MAX_FRACTIONAL_DIGITS = 2;

package/dist/registry/charts-core/util/format/constants.js

@@ -0,0 +1,3 @@
+const NULL_STRING = "NULL";
+const MAX_FRACTIONAL_DIGITS = 2;
+export { MAX_FRACTIONAL_DIGITS, NULL_STRING };

package/dist/registry/charts-core/util/format/duration-unit.d.ts

@@ -0,0 +1 @@
+export type DurationUnit = "year" | "month" | "day" | "hour" | "minute" | "second";

package/dist/registry/charts-core/util/format/format-boolean.d.ts

@@ -0,0 +1,5 @@
+export interface FormatBooleanOptions {
+    trueLabel?: string;
+    falseLabel?: string;
+}
+export declare const formatBoolean: (value: boolean, { trueLabel, falseLabel }?: FormatBooleanOptions) => string;

package/dist/registry/charts-core/util/format/format-boolean.js

@@ -0,0 +1,2 @@
+const formatBoolean = (value, { trueLabel = "True", falseLabel = "False" } = {})=>value ? trueLabel : falseLabel;
+export { formatBoolean };

package/dist/registry/charts-core/util/format/format-currency.d.ts

@@ -0,0 +1,5 @@
+import type { BaseFormatOptions } from "./base-format-options";
+export interface FormatCurrencyOptions extends BaseFormatOptions {
+    currency?: string;
+}
+export declare const formatCurrency: (locale: Intl.LocalesArgument, value: number, settings?: FormatCurrencyOptions) => string;

package/dist/registry/charts-core/util/format/format-currency.js

@@ -0,0 +1,16 @@
+import { MAX_FRACTIONAL_DIGITS } from "./constants.js";
+const formatCurrency = (locale, value, settings = {})=>{
+    const { notation, currency = "USD" } = settings;
+    const isCompact = "compact" === notation;
+    const isLowNumber = null != value && value < 1000;
+    const compactMinimumFractionDigits = isLowNumber ? 2 : 0;
+    return Intl.NumberFormat(locale, {
+        style: "currency",
+        currency,
+        minimumFractionDigits: isCompact ? compactMinimumFractionDigits : 2,
+        maximumFractionDigits: MAX_FRACTIONAL_DIGITS,
+        compactDisplay: "short",
+        notation
+    }).format(value);
+};
+export { formatCurrency };

package/dist/registry/charts-core/util/format/format-date.d.ts

@@ -0,0 +1,15 @@
+import { DateTime } from "luxon";
+export interface OverrideTimeOptions {
+    year?: "numeric";
+    month?: "short" | "long";
+    day?: "numeric";
+    hour?: "numeric" | "2-digit";
+    minute?: "numeric" | "2-digit";
+    second?: "2-digit";
+    hourCycle?: "h23" | "h12";
+    timeStyle?: "short";
+    weekday?: "long" | "short";
+    fractionalSecondDigits?: 3 | undefined;
+    hideEmptyTime?: boolean;
+}
+export declare const formatDate: (locale: Intl.LocalesArgument, value: string | DateTime, options?: OverrideTimeOptions) => string;

package/dist/registry/charts-core/util/format/format-date.js

@@ -0,0 +1,35 @@
+import { DateTime } from "luxon";
+import { isDateOnly } from "./is-date-only.js";
+const commonOptions = {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    fractionalSecondDigits: 3
+};
+const applicationDataOptions = {
+    ...commonOptions,
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hourCycle: "h23"
+};
+const formatDate = (locale, value, options)=>{
+    const formatOptions = options ?? applicationDataOptions;
+    const date = value instanceof DateTime ? value : DateTime.fromISO(value);
+    const hasHiddenTime = options?.hideEmptyTime && isDateOnly(date);
+    const hasMs = 0 !== date.millisecond;
+    const resultingOptions = {
+        ...formatOptions
+    };
+    if (!hasMs) delete resultingOptions.fractionalSecondDigits;
+    if (hasHiddenTime) {
+        delete resultingOptions.hour;
+        delete resultingOptions.minute;
+        delete resultingOptions.second;
+    }
+    return Intl.DateTimeFormat(locale, {
+        ...resultingOptions,
+        timeZone: "UTC"
+    }).format(date.toJSDate());
+};
+export { formatDate };

package/dist/registry/charts-core/util/format/format-duration.d.ts

@@ -0,0 +1,9 @@
+import type { Duration } from "luxon";
+import type { DurationUnit } from "./duration-unit";
+export interface FormatDurationOptions {
+    units?: DurationUnit[];
+    isRounded?: boolean;
+    compact?: boolean;
+    compactUnit?: boolean;
+}
+export declare const formatDuration: (locale: Intl.LocalesArgument, value: Duration, options?: FormatDurationOptions) => string;

package/dist/registry/charts-core/util/format/format-duration.js

@@ -0,0 +1,27 @@
+import { MAX_FRACTIONAL_DIGITS } from "./constants.js";
+import { highestDurationUnit } from "./highest-duration-unit.js";
+const formatDuration = (locale, value, options)=>{
+    const units = options?.units ?? [
+        highestDurationUnit(value)
+    ];
+    const hasCompactUnit = options?.compactUnit ?? false;
+    const isCompact = options?.compact ?? false;
+    const durationObj = value.shiftTo(...units);
+    const formattedUnits = units.map((unit)=>{
+        const unitValue = options?.isRounded ? Math.round(durationObj.get(unit)) : durationObj.get(unit);
+        return Intl.NumberFormat(locale, {
+            style: "unit",
+            unit,
+            unitDisplay: hasCompactUnit ? "narrow" : "short",
+            notation: isCompact ? "compact" : "standard",
+            maximumFractionDigits: MAX_FRACTIONAL_DIGITS,
+            minimumFractionDigits: MAX_FRACTIONAL_DIGITS,
+            trailingZeroDisplay: "stripIfInteger"
+        }).format(unitValue);
+    });
+    return new Intl.ListFormat(locale, {
+        type: "unit",
+        style: "narrow"
+    }).format(formattedUnits);
+};
+export { formatDuration };

package/dist/registry/charts-core/util/format/format-metric-value.d.ts

@@ -0,0 +1,3 @@
+import type { MetricExpression } from "../../models/expression";
+import type { BaseFormatOptions } from "./base-format-options";
+export declare function formatMetricValue(locale: Intl.LocalesArgument, value: unknown, expression: MetricExpression, options?: BaseFormatOptions): string;

package/dist/registry/charts-core/util/format/format-metric-value.js

@@ -0,0 +1,26 @@
+import { getMetricFieldType } from "../get-metric-field-type.js";
+import { format } from "./format.js";
+function formatMetricValue(locale, value, expression, options) {
+    const fieldType = getMetricFieldType(expression);
+    if ("currency" === fieldType && "currency" === expression.argument.type) {
+        const fmt = expression.argument.format;
+        return format(locale, value, "currency", {
+            ...options,
+            ...fmt && {
+                currency: fmt.currency
+            }
+        });
+    }
+    if ("boolean" === fieldType && "boolean" === expression.argument.type) {
+        const fmt = expression.argument.format;
+        return format(locale, value, "boolean", {
+            ...options,
+            ...fmt && {
+                trueLabel: fmt.trueDisplay,
+                falseLabel: fmt.falseDisplay
+            }
+        });
+    }
+    return format(locale, value, fieldType, options);
+}
+export { formatMetricValue };

package/dist/registry/charts-core/util/format/format-number.d.ts

@@ -0,0 +1,2 @@
+import type { BaseFormatOptions } from "./base-format-options";
+export declare const formatNumber: (locale: Intl.LocalesArgument, value: number, settings?: BaseFormatOptions) => string;

package/dist/registry/charts-core/util/format/format-number.js

@@ -0,0 +1,12 @@
+import { MAX_FRACTIONAL_DIGITS } from "./constants.js";
+const formatNumber = (locale, value, settings = {})=>{
+    const { notation } = settings;
+    const formattedValue = Intl.NumberFormat(locale, {
+        notation,
+        maximumFractionDigits: MAX_FRACTIONAL_DIGITS,
+        minimumFractionDigits: MAX_FRACTIONAL_DIGITS,
+        trailingZeroDisplay: "stripIfInteger"
+    }).format(value);
+    return formattedValue;
+};
+export { formatNumber };

package/dist/registry/charts-core/util/format/format-percentage.d.ts

@@ -0,0 +1,2 @@
+import type { PercentageFormatOptions } from "./percentage-format-options";
+export declare const formatPercentage: (locale: Intl.LocalesArgument, value: number, settings?: PercentageFormatOptions) => string;

package/dist/registry/charts-core/util/format/format-percentage.js

@@ -0,0 +1,27 @@
+import { MAX_FRACTIONAL_DIGITS } from "./constants.js";
+const formatPercentageImpl = (locale, value, settings = {})=>{
+    const { notation } = settings;
+    if ("minimal" === notation) return Intl.NumberFormat(locale, {
+        style: "percent",
+        maximumFractionDigits: 0,
+        notation: "compact"
+    }).format(value);
+    return Intl.NumberFormat(locale, {
+        style: "percent",
+        maximumFractionDigits: MAX_FRACTIONAL_DIGITS,
+        minimumFractionDigits: MAX_FRACTIONAL_DIGITS,
+        trailingZeroDisplay: "stripIfInteger",
+        notation
+    }).format(value);
+};
+const formatPercentage = (locale, value, settings = {})=>{
+    const isExactlyZero = 0 === value;
+    const isExactlyOne = 1 === value;
+    const zeroLabel = formatPercentageImpl(locale, 0, settings);
+    const hundredLabel = formatPercentageImpl(locale, 1, settings);
+    const label = formatPercentageImpl(locale, value, settings);
+    if (label === zeroLabel && !isExactlyZero) return `≈${zeroLabel}`;
+    if (label === hundredLabel && !isExactlyOne) return `≈${hundredLabel}`;
+    return label;
+};
+export { formatPercentage };

package/dist/registry/charts-core/util/format/format.d.ts

@@ -0,0 +1,18 @@
+import type { BaseFormatOptions } from "./base-format-options";
+import { type FormatBooleanOptions } from "./format-boolean";
+import { type FormatCurrencyOptions } from "./format-currency";
+import type { FormatDurationOptions } from "./format-duration";
+type DataModelFieldType = "string" | "boolean" | "id" | "ref" | "duration" | "numeric" | "currency" | "datetime" | "percentage";
+type TypeToFormat = {
+    currency: FormatCurrencyOptions;
+    duration: FormatDurationOptions;
+    percentage: BaseFormatOptions;
+    datetime: BaseFormatOptions;
+    numeric: BaseFormatOptions;
+    boolean: FormatBooleanOptions;
+    string: BaseFormatOptions;
+    id: BaseFormatOptions;
+    ref: BaseFormatOptions;
+};
+export declare const format: <TFieldType extends DataModelFieldType>(locale: Intl.LocalesArgument, value: unknown, fieldType: TFieldType, options?: TypeToFormat[TFieldType]) => string;
+export {};

package/dist/registry/charts-core/util/format/format.js

@@ -0,0 +1,36 @@
+import { Duration } from "luxon";
+import { assert } from "../../../../lib/asserts/assert.js";
+import { assertBoolean } from "../../../../lib/asserts/assert-boolean.js";
+import { assertDateTimeOrString } from "../../../../lib/asserts/assert-date-time-or-string.js";
+import { assertNumber } from "../../../../lib/asserts/assert-number.js";
+import { NULL_STRING } from "./constants.js";
+import { formatBoolean } from "./format-boolean.js";
+import { formatCurrency } from "./format-currency.js";
+import { formatDate } from "./format-date.js";
+import { formatDuration } from "./format-duration.js";
+import { formatNumber } from "./format-number.js";
+import { formatPercentage } from "./format-percentage.js";
+const format = (locale, value, fieldType, options = {})=>{
+    if (null == value) return NULL_STRING;
+    switch(fieldType){
+        case "datetime":
+            return formatDate(locale, assertDateTimeOrString(value, "Date time value"));
+        case "numeric":
+            return formatNumber(locale, assertNumber(value, "Format numeric value"), options);
+        case "currency":
+            return formatCurrency(locale, assertNumber(value, "Format currency value"), options);
+        case "duration":
+            return formatDuration(locale, Duration.fromMillis(assertNumber(value, "Format duration value")), options);
+        case "percentage":
+            return formatPercentage(locale, assertNumber(value, "Format percentage value"), options);
+        case "boolean":
+            return formatBoolean(assertBoolean(value, "Format value"), options);
+        case "string":
+        case "id":
+        case "ref":
+            return "string" == typeof value ? value : JSON.stringify(value);
+        default:
+            assert(false, "Unknown format type");
+    }
+};
+export { format };

package/dist/registry/charts-core/util/format/get-chart-range.d.ts

@@ -0,0 +1,10 @@
+import { Interval } from "luxon";
+interface GetChartRangeProps {
+    type: "numeric" | "datetime";
+    bins: Array<Interval | {
+        start: number;
+        end: number;
+    }>;
+}
+export declare const getChartRange: ({ type, bins }: GetChartRangeProps) => Interval<true> | undefined;
+export {};

package/dist/registry/charts-core/util/format/get-chart-range.js

@@ -0,0 +1,11 @@
+import { DateTime, Interval } from "luxon";
+import { assert } from "../../../../lib/asserts/assert.js";
+const getChartRange = ({ type, bins })=>{
+    if ("datetime" !== type || 0 === bins.length) return;
+    const start = bins[0]?.start;
+    const end = bins.at(-1)?.end;
+    assert(start instanceof DateTime, "Chart range min must be a DateTime");
+    assert(end instanceof DateTime, "Chart range max must be a DateTime");
+    return Interval.fromDateTimes(start, end);
+};
+export { getChartRange };

package/dist/registry/charts-core/util/format/highest-duration-unit.d.ts

@@ -0,0 +1,3 @@
+import type { Duration } from "luxon";
+import type { DurationUnit } from "./duration-unit";
+export declare const highestDurationUnit: (duration: Duration) => DurationUnit;

package/dist/registry/charts-core/util/format/highest-duration-unit.js

@@ -0,0 +1,7 @@
+const highestDurationUnit = (duration)=>{
+    if (Math.abs(duration.shiftTo("days").days) > 1) return "day";
+    if (Math.abs(duration.shiftTo("hours").hours) > 1) return "hour";
+    if (Math.abs(duration.shiftTo("minutes").minutes) > 1) return "minute";
+    return "second";
+};
+export { highestDurationUnit };

package/dist/registry/charts-core/util/format/is-date-only.d.ts

@@ -0,0 +1,2 @@
+import type { DateTime } from "luxon";
+export declare function isDateOnly(date: DateTime): boolean;

package/dist/registry/charts-core/util/format/is-date-only.js

@@ -0,0 +1,4 @@
+function isDateOnly(date) {
+    return 0 === date.hour && 0 === date.minute && 0 === date.second && 0 === date.millisecond;
+}
+export { isDateOnly };

package/dist/registry/charts-core/util/format/percentage-format-options.d.ts

@@ -0,0 +1,3 @@
+export interface PercentageFormatOptions {
+    notation?: "compact" | "minimal";
+}

package/dist/registry/charts-core/util/get-metric-field-type.d.ts

@@ -0,0 +1,3 @@
+import type { MetricExpression } from "../models/expression";
+import type { DataModelFieldType } from "../models/field";
+export declare function getMetricFieldType(expression: MetricExpression): DataModelFieldType;

package/dist/registry/charts-core/util/get-metric-field-type.js

@@ -0,0 +1,18 @@
+function getMetricFieldType(expression) {
+    switch(expression.aggregation){
+        case "COUNT":
+        case "DISTINCT_COUNT":
+            return "numeric";
+        case "PERCENTAGE":
+            return "percentage";
+        case "ANY":
+        case "AVERAGE":
+        case "MAX":
+        case "MEDIAN":
+        case "MIN":
+        case "PERCENTILE":
+        case "SUM":
+            return expression.argument.type;
+    }
+}
+export { getMetricFieldType };

package/dist/registry/checkbox/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+import * as React from "react";
+declare function Checkbox({ className, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+export { Checkbox };

package/dist/registry/checkbox/checkbox.js

@@ -0,0 +1,21 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { Indicator, Root } from "@radix-ui/react-checkbox";
+import { CheckIcon } from "lucide-react";
+import "react";
+import { cn } from "../../lib/utils.js";
+function Checkbox({ className, ...props }) {
+    return /*#__PURE__*/ jsx(Root, {
+        "data-slot": "checkbox",
+        className: cn("peer border-input dark:bg-input/30 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground dark:data-[state=checked]:bg-primary data-[state=checked]:border-primary focus-visible:border-ring focus-visible:ring-ring/50 aria-invalid:ring-destructive/20 dark:aria-invalid:ring-destructive/40 aria-invalid:border-destructive size-4 shrink-0 rounded-[4px] border shadow-xs transition-shadow outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50", className),
+        ...props,
+        children: /*#__PURE__*/ jsx(Indicator, {
+            "data-slot": "checkbox-indicator",
+            className: "grid place-content-center text-current transition-none",
+            children: /*#__PURE__*/ jsx(CheckIcon, {
+                className: "size-3.5"
+            })
+        })
+    });
+}
+export { Checkbox };

package/dist/registry/collapsible/collapsible.d.ts

@@ -0,0 +1,5 @@
+import * as CollapsiblePrimitive from "@radix-ui/react-collapsible";
+declare function Collapsible({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleTrigger({ ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleTrigger>): import("react/jsx-runtime").JSX.Element;
+declare function CollapsibleContent({ className, ...props }: React.ComponentProps<typeof CollapsiblePrimitive.CollapsibleContent>): import("react/jsx-runtime").JSX.Element;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/registry/collapsible/collapsible.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { CollapsibleContent, CollapsibleTrigger, Root } from "@radix-ui/react-collapsible";
+import { cn } from "../../lib/utils.js";
+function Collapsible({ ...props }) {
+    return /*#__PURE__*/ jsx(Root, {
+        "data-slot": "collapsible",
+        ...props
+    });
+}
+function collapsible_CollapsibleTrigger({ ...props }) {
+    return /*#__PURE__*/ jsx(CollapsibleTrigger, {
+        "data-slot": "collapsible-trigger",
+        ...props
+    });
+}
+function collapsible_CollapsibleContent({ className, ...props }) {
+    return /*#__PURE__*/ jsx(CollapsibleContent, {
+        "data-slot": "collapsible-content",
+        className: cn("overflow-hidden transition-all duration-200 data-[state=closed]:animate-collapsible-up data-[state=open]:animate-collapsible-down", className),
+        ...props
+    });
+}
+export { Collapsible, collapsible_CollapsibleContent as CollapsibleContent, collapsible_CollapsibleTrigger as CollapsibleTrigger };

package/dist/registry/combobox/combobox.d.ts

@@ -0,0 +1,42 @@
+import * as React from "react";
+import { Badge } from "../badge/badge";
+import { CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from "../command/command";
+import { PopoverContent } from "../popover/popover";
+interface ComboboxProps {
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    multiple?: boolean;
+    value?: string[];
+    onValueChange?: (values: string[]) => void;
+    children: React.ReactNode;
+}
+declare function Combobox({ open: controlledOpen, onOpenChange, multiple, value: controlledValue, onValueChange, children, }: ComboboxProps): import("react/jsx-runtime").JSX.Element;
+interface ComboboxTriggerProps extends React.ComponentProps<"div"> {
+    placeholder?: string;
+}
+declare function ComboboxTrigger({ className, placeholder, children, "aria-invalid": ariaInvalid, ...props }: ComboboxTriggerProps): import("react/jsx-runtime").JSX.Element;
+interface ComboboxContentProps extends React.ComponentProps<typeof PopoverContent> {
+    filter?: (value: string, search: string, keywords?: string[]) => number;
+}
+declare function ComboboxContent({ className, children, filter, ...props }: ComboboxContentProps): import("react/jsx-runtime").JSX.Element;
+type ComboboxInputProps = React.ComponentProps<typeof CommandInput>;
+declare function ComboboxInput({ ...props }: ComboboxInputProps): import("react/jsx-runtime").JSX.Element;
+type ComboboxListProps = React.ComponentProps<typeof CommandList>;
+declare function ComboboxList({ className, ...props }: ComboboxListProps): import("react/jsx-runtime").JSX.Element;
+type ComboboxEmptyProps = React.ComponentProps<typeof CommandEmpty>;
+declare function ComboboxEmpty({ ...props }: ComboboxEmptyProps): import("react/jsx-runtime").JSX.Element;
+type ComboboxGroupProps = React.ComponentProps<typeof CommandGroup>;
+declare function ComboboxGroup({ ...props }: ComboboxGroupProps): import("react/jsx-runtime").JSX.Element;
+interface ComboboxItemProps extends Omit<React.ComponentProps<typeof CommandItem>, "onSelect"> {
+    value: string;
+}
+declare function ComboboxItem({ className, value: itemValue, children, ...props }: ComboboxItemProps): import("react/jsx-runtime").JSX.Element;
+type ComboboxBadgeListProps = React.ComponentProps<"div">;
+declare function ComboboxBadgeList({ className, ...props }: ComboboxBadgeListProps): import("react/jsx-runtime").JSX.Element;
+interface ComboboxBadgeProps extends React.ComponentProps<typeof Badge> {
+    value: string;
+    onRemove?: () => void;
+}
+declare function ComboboxBadge({ className, value: itemValue, onRemove, children, ...props }: ComboboxBadgeProps): import("react/jsx-runtime").JSX.Element;
+export { Combobox, ComboboxTrigger, ComboboxContent, ComboboxInput, ComboboxList, ComboboxEmpty, ComboboxGroup, ComboboxItem, ComboboxBadgeList, ComboboxBadge, };
+export type { ComboboxProps, ComboboxTriggerProps, ComboboxContentProps, ComboboxInputProps, ComboboxListProps, ComboboxEmptyProps, ComboboxGroupProps, ComboboxItemProps, ComboboxBadgeListProps, ComboboxBadgeProps, };