@ciridae/ui-agent 0.3.2 → 0.3.6

package/dist/components/agentic/attachments-context.js

@@ -0,0 +1,196 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/* eslint-disable react-refresh/only-export-components */
+import * as React from "react";
+import { captureBrowserScreenshot, fileToAttachment, getAttachmentError, getInitialScreenshotStatus, isScreenshotSupported, isIgnoredScreenshotError, revokeObjectUrls, revokeOwnedObjectUrls, revokeRemovedObjectUrls, } from "./attachments-model";
+const AttachmentControllerContext = React.createContext(null);
+const AttachmentsContext = React.createContext(null);
+const AttachmentItemContext = React.createContext(null);
+function AttachmentProvider({ accept, attachments, children, defaultAttachments = [], maxAttachmentSizeMb = 10, maxAttachments = 4, multiple = true, onAttachmentError, onAttachmentsChange, onCaptureScreenshot, }) {
+    const fileInputRef = React.useRef(null);
+    const { files, filesRef, ownedObjectUrlsRef, updateAttachments } = useAttachmentFileState({
+        attachments,
+        defaultAttachments,
+        onAttachmentsChange,
+    });
+    const { add, clear, error, openFileDialog, remove } = useAttachmentMutations({
+        accept,
+        fileInputRef,
+        filesRef,
+        maxAttachmentSizeMb,
+        maxAttachments,
+        onAttachmentError,
+        ownedObjectUrlsRef,
+        updateAttachments,
+    });
+    const { screenshotStatus, takeScreenshot } = useAttachmentScreenshot({
+        add,
+        onCaptureScreenshot,
+    });
+    const contextValue = React.useMemo(() => ({
+        accept,
+        add,
+        clear,
+        error,
+        files,
+        maxAttachmentSizeMb,
+        maxAttachments,
+        openFileDialog,
+        remove,
+        screenshotStatus,
+        takeScreenshot,
+    }), [
+        accept,
+        add,
+        clear,
+        error,
+        files,
+        maxAttachmentSizeMb,
+        maxAttachments,
+        openFileDialog,
+        remove,
+        screenshotStatus,
+        takeScreenshot,
+    ]);
+    return (_jsxs(AttachmentControllerContext.Provider, { value: contextValue, children: [_jsx("input", { "aria-hidden": "true", accept: accept, className: "hidden", multiple: multiple, onChange: (event) => {
+                    if (event.currentTarget.files)
+                        add(event.currentTarget.files);
+                    event.currentTarget.value = "";
+                }, ref: fileInputRef, tabIndex: -1, type: "file" }), children] }));
+}
+function useAttachmentFileState({ attachments, defaultAttachments, onAttachmentsChange, }) {
+    const isControlled = attachments !== undefined;
+    const isControlledRef = React.useRef(isControlled);
+    const [localAttachments, setLocalAttachments] = React.useState(defaultAttachments);
+    const files = attachments ?? localAttachments;
+    const filesRef = React.useRef(files);
+    const ownedObjectUrlsRef = React.useRef(new Set());
+    React.useEffect(() => {
+        const previous = filesRef.current;
+        if (previous !== files) {
+            if (isControlled)
+                revokeRemovedObjectUrls(previous, files, ownedObjectUrlsRef.current);
+            filesRef.current = files;
+        }
+    }, [files, isControlled]);
+    React.useEffect(() => {
+        isControlledRef.current = isControlled;
+    }, [isControlled]);
+    React.useEffect(() => () => {
+        if (isControlledRef.current)
+            revokeOwnedObjectUrls(ownedObjectUrlsRef.current);
+        else
+            revokeObjectUrls(filesRef.current);
+    }, []);
+    const updateAttachments = React.useCallback((updater) => {
+        const previous = filesRef.current;
+        const next = updater(previous);
+        filesRef.current = next;
+        if (isControlled) {
+            revokeRemovedObjectUrls(previous, next, ownedObjectUrlsRef.current);
+        }
+        else {
+            revokeRemovedObjectUrls(previous, next);
+            setLocalAttachments(next);
+        }
+        onAttachmentsChange?.(next);
+    }, [isControlled, onAttachmentsChange]);
+    return { files, filesRef, ownedObjectUrlsRef, updateAttachments };
+}
+function useAttachmentMutations({ accept, fileInputRef, filesRef, maxAttachmentSizeMb, maxAttachments, onAttachmentError, ownedObjectUrlsRef, updateAttachments, }) {
+    const [error, setError] = React.useState();
+    const reportError = React.useCallback((nextError) => {
+        setError(nextError);
+        onAttachmentError?.(nextError);
+    }, [onAttachmentError]);
+    const add = React.useCallback((fileList, options) => {
+        const incoming = Array.from(fileList);
+        if (incoming.length === 0)
+            return;
+        const validationError = getAttachmentError({
+            accept,
+            currentCount: filesRef.current.length,
+            files: incoming,
+            maxAttachmentSizeMb,
+            maxAttachments,
+        });
+        if (validationError) {
+            reportError(validationError);
+            return;
+        }
+        const nextAttachments = incoming.map((file) => {
+            const attachment = fileToAttachment(file, options?.kind ?? "file");
+            if (attachment.url?.startsWith("blob:"))
+                ownedObjectUrlsRef.current.add(attachment.url);
+            return attachment;
+        });
+        setError(undefined);
+        updateAttachments((current) => [...current, ...nextAttachments]);
+        if (fileInputRef.current)
+            fileInputRef.current.value = "";
+    }, [
+        accept,
+        fileInputRef,
+        filesRef,
+        maxAttachmentSizeMb,
+        maxAttachments,
+        ownedObjectUrlsRef,
+        reportError,
+        updateAttachments,
+    ]);
+    const remove = React.useCallback((id) => {
+        updateAttachments((current) => current.filter((attachment) => attachment.id !== id));
+    }, [updateAttachments]);
+    const clear = React.useCallback(() => {
+        updateAttachments(() => []);
+    }, [updateAttachments]);
+    const openFileDialog = React.useCallback(() => {
+        fileInputRef.current?.click();
+    }, [fileInputRef]);
+    return { add, clear, error, openFileDialog, remove };
+}
+function useAttachmentScreenshot({ add, onCaptureScreenshot, }) {
+    const [screenshotStatus, setScreenshotStatus] = React.useState(() => getInitialScreenshotStatus(onCaptureScreenshot));
+    React.useEffect(() => {
+        setScreenshotStatus(getInitialScreenshotStatus(onCaptureScreenshot));
+    }, [onCaptureScreenshot]);
+    const takeScreenshot = React.useCallback(async () => {
+        setScreenshotStatus("capturing");
+        try {
+            const screenshot = onCaptureScreenshot
+                ? await onCaptureScreenshot()
+                : await captureBrowserScreenshot();
+            if (screenshot)
+                add([screenshot], { kind: "screenshot" });
+            setScreenshotStatus(isScreenshotSupported() || onCaptureScreenshot ? "idle" : "unavailable");
+        }
+        catch (screenshotError) {
+            if (isIgnoredScreenshotError(screenshotError)) {
+                setScreenshotStatus("idle");
+                return;
+            }
+            setScreenshotStatus("error");
+        }
+    }, [add, onCaptureScreenshot]);
+    return { screenshotStatus, takeScreenshot };
+}
+function useAttachments() {
+    const context = React.useContext(AttachmentControllerContext);
+    if (!context) {
+        throw new Error("useAttachments must be used within AttachmentProvider.");
+    }
+    return context;
+}
+function useOptionalAttachments() {
+    return React.useContext(AttachmentControllerContext);
+}
+function useAttachmentsContext() {
+    return React.useContext(AttachmentsContext) ?? { variant: "grid" };
+}
+function useAttachmentContext() {
+    const context = React.useContext(AttachmentItemContext);
+    if (!context) {
+        throw new Error("Attachment components must be used within Attachment.");
+    }
+    return context;
+}
+export { AttachmentControllerContext, AttachmentItemContext, AttachmentProvider, AttachmentsContext, useAttachmentContext, useAttachments, useAttachmentsContext, useOptionalAttachments, };

package/dist/components/agentic/attachments-model.d.ts

@@ -0,0 +1,23 @@
+import type { AgenticPromptAttachmentKind } from "./types";
+import type { AgenticAttachment, AttachmentData, AttachmentError, AttachmentMediaCategory, AttachmentProviderProps, AttachmentScreenshotStatus, AttachmentVariant } from "./attachments-types";
+export declare function prepareAttachmentsForSubmit(attachments: AgenticAttachment[]): Promise<AgenticAttachment[]>;
+export declare function fileToAttachment(file: File, kind?: AgenticPromptAttachmentKind): AgenticAttachment;
+export declare function getMediaCategory(data: AttachmentData): AttachmentMediaCategory;
+export declare function getAttachmentLabel(data: AttachmentData): string;
+export declare function getAttachmentError({ accept, currentCount, files, maxAttachmentSizeMb, maxAttachments, }: {
+    accept: string | undefined;
+    currentCount: number;
+    files: File[];
+    maxAttachmentSizeMb: number;
+    maxAttachments: number;
+}): AttachmentError | undefined;
+export declare function captureBrowserScreenshot(): Promise<File | null>;
+export declare function isScreenshotSupported(): boolean;
+export declare function getInitialScreenshotStatus(onCaptureScreenshot?: AttachmentProviderProps["onCaptureScreenshot"]): AttachmentScreenshotStatus;
+export declare function isIgnoredScreenshotError(error: unknown): boolean;
+export declare function revokeRemovedObjectUrls(previousAttachments: AgenticAttachment[], nextAttachments: AgenticAttachment[], ownedUrls?: Set<string>): void;
+export declare function revokeObjectUrls(attachments: AgenticAttachment[]): void;
+export declare function revokeOwnedObjectUrls(ownedUrls: Set<string>): void;
+export declare function getAttachmentMeta(attachment: AttachmentData | undefined): string | null;
+export declare function getAttachmentRemoveSize(variant: AttachmentVariant): "icon-sm" | "icon-xs";
+export declare function getScreenshotLabel(status: AttachmentScreenshotStatus): "Capturing screenshot" | "Screenshot unavailable" | "Screenshot failed" | "Add screenshot";

package/dist/components/agentic/attachments-model.js

@@ -0,0 +1,226 @@
+export async function prepareAttachmentsForSubmit(attachments) {
+    return await Promise.all(attachments.map(attachmentToSubmitAttachment));
+}
+export function fileToAttachment(file, kind = "file") {
+    return {
+        file,
+        filename: file.name,
+        id: createAttachmentId(),
+        kind,
+        mediaType: file.type,
+        name: file.name,
+        size: file.size,
+        status: "complete",
+        type: "file",
+        url: URL.createObjectURL(file),
+    };
+}
+export function getMediaCategory(data) {
+    if (data.type === "source-document" || data.kind === "source")
+        return "source";
+    const mediaType = data.mediaType ?? "";
+    if (mediaType.startsWith("image/"))
+        return "image";
+    if (mediaType.startsWith("video/"))
+        return "video";
+    if (mediaType.startsWith("audio/"))
+        return "audio";
+    if (mediaType.startsWith("application/") || mediaType.startsWith("text/"))
+        return "document";
+    return "unknown";
+}
+export function getAttachmentLabel(data) {
+    if (data.type === "source-document" || data.kind === "source") {
+        return data.title || data.filename || data.name || "Source";
+    }
+    const category = getMediaCategory(data);
+    return data.filename || data.name || (category === "image" ? "Image" : "Attachment");
+}
+async function attachmentToSubmitAttachment(attachment) {
+    if (!attachment.url?.startsWith("blob:"))
+        return attachment;
+    const dataUrl = await convertBlobUrlToDataUrl(attachment.url);
+    return {
+        ...attachment,
+        url: dataUrl ?? attachment.url,
+    };
+}
+async function convertBlobUrlToDataUrl(url) {
+    try {
+        const response = await fetch(url);
+        const blob = await response.blob();
+        return await new Promise((resolve) => {
+            const reader = new FileReader();
+            reader.onloadend = () => {
+                const result = reader.result;
+                resolve(typeof result === "string" ? result : null);
+            };
+            reader.onerror = () => resolve(null);
+            reader.readAsDataURL(blob);
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export function getAttachmentError({ accept, currentCount, files, maxAttachmentSizeMb, maxAttachments, }) {
+    if (currentCount + files.length > maxAttachments) {
+        return { code: "max_attachments", message: `Attach up to ${maxAttachments} files.` };
+    }
+    const oversizedFile = files.find((file) => file.size > maxAttachmentSizeMb * 1024 * 1024);
+    if (oversizedFile) {
+        return {
+            code: "max_attachment_size",
+            message: `${oversizedFile.name} is larger than ${maxAttachmentSizeMb} MB.`,
+        };
+    }
+    const unsupportedFile = files.find((file) => !isAcceptedFile(file, accept));
+    if (unsupportedFile) {
+        return { code: "accept", message: `${unsupportedFile.name} is not an accepted file type.` };
+    }
+    return undefined;
+}
+function isAcceptedFile(file, accept) {
+    if (!accept)
+        return true;
+    const rules = accept
+        .split(",")
+        .map((rule) => rule.trim().toLowerCase())
+        .filter(Boolean);
+    const fileName = file.name.toLowerCase();
+    const fileType = file.type.toLowerCase();
+    return rules.some((rule) => {
+        if (rule === "*/*")
+            return true;
+        if (rule.startsWith("."))
+            return fileName.endsWith(rule);
+        if (rule.endsWith("/*"))
+            return fileType.startsWith(rule.slice(0, -1));
+        return fileType === rule;
+    });
+}
+export async function captureBrowserScreenshot() {
+    if (!isScreenshotSupported())
+        return null;
+    let stream = null;
+    const video = document.createElement("video");
+    video.muted = true;
+    video.playsInline = true;
+    try {
+        stream = await navigator.mediaDevices.getDisplayMedia({ audio: false, video: true });
+        video.srcObject = stream;
+        await new Promise((resolve, reject) => {
+            video.onloadedmetadata = () => resolve();
+            video.onerror = () => reject(new Error("Failed to load screen stream."));
+        });
+        await video.play();
+        if (!video.videoWidth || !video.videoHeight)
+            return null;
+        const canvas = document.createElement("canvas");
+        canvas.width = video.videoWidth;
+        canvas.height = video.videoHeight;
+        const context = canvas.getContext("2d");
+        if (!context)
+            return null;
+        context.drawImage(video, 0, 0, canvas.width, canvas.height);
+        const blob = await new Promise((resolve) => {
+            canvas.toBlob(resolve, "image/png");
+        });
+        if (!blob)
+            return null;
+        return new File([blob], `screenshot-${getScreenshotTimestamp()}.png`, {
+            lastModified: Date.now(),
+            type: "image/png",
+        });
+    }
+    finally {
+        if (stream) {
+            for (const track of stream.getTracks())
+                track.stop();
+        }
+        video.pause();
+        video.srcObject = null;
+    }
+}
+export function isScreenshotSupported() {
+    return typeof navigator !== "undefined" && !!navigator.mediaDevices?.getDisplayMedia;
+}
+export function getInitialScreenshotStatus(onCaptureScreenshot) {
+    return onCaptureScreenshot || isScreenshotSupported() ? "idle" : "unavailable";
+}
+export function isIgnoredScreenshotError(error) {
+    return (error instanceof DOMException &&
+        (error.name === "NotAllowedError" || error.name === "AbortError"));
+}
+export function revokeRemovedObjectUrls(previousAttachments, nextAttachments, ownedUrls) {
+    const nextUrls = new Set(nextAttachments.map((attachment) => attachment.url).filter(Boolean));
+    const removedAttachments = previousAttachments.filter((attachment) => attachment.url &&
+        !nextUrls.has(attachment.url) &&
+        (!ownedUrls || ownedUrls.has(attachment.url)));
+    revokeObjectUrls(removedAttachments);
+    if (ownedUrls) {
+        for (const attachment of removedAttachments) {
+            if (attachment.url)
+                ownedUrls.delete(attachment.url);
+        }
+    }
+}
+export function revokeObjectUrls(attachments) {
+    for (const attachment of attachments) {
+        if (attachment.url?.startsWith("blob:"))
+            URL.revokeObjectURL(attachment.url);
+    }
+}
+export function revokeOwnedObjectUrls(ownedUrls) {
+    for (const url of ownedUrls) {
+        URL.revokeObjectURL(url);
+    }
+    ownedUrls.clear();
+}
+export function getAttachmentMeta(attachment) {
+    if (!attachment)
+        return null;
+    if (attachment.error)
+        return attachment.error;
+    const parts = [getMediaLabel(attachment), formatFileSize(attachment.size)].filter(Boolean);
+    return parts.join(" · ");
+}
+function getMediaLabel(attachment) {
+    if (attachment.kind === "screenshot")
+        return "Screenshot";
+    if (attachment.kind === "source" || attachment.type === "source-document")
+        return "Source";
+    if (!attachment.mediaType)
+        return "File";
+    const mediaTypeParts = attachment.mediaType.split("/");
+    return mediaTypeParts[mediaTypeParts.length - 1]?.toUpperCase() ?? "File";
+}
+function formatFileSize(size) {
+    if (size === undefined)
+        return undefined;
+    if (size < 1024)
+        return `${size} B`;
+    if (size < 1024 * 1024)
+        return `${Math.round(size / 1024)} KB`;
+    return `${(size / 1024 / 1024).toFixed(1)} MB`;
+}
+export function getAttachmentRemoveSize(variant) {
+    if (variant === "list")
+        return "icon-sm";
+    return "icon-xs";
+}
+export function getScreenshotLabel(status) {
+    if (status === "capturing")
+        return "Capturing screenshot";
+    if (status === "unavailable")
+        return "Screenshot unavailable";
+    if (status === "error")
+        return "Screenshot failed";
+    return "Add screenshot";
+}
+function getScreenshotTimestamp() {
+    return new Date().toISOString().replace(/[:.]/g, "-").replace("T", "_").replace("Z", "");
+}
+function createAttachmentId() {
+    return globalThis.crypto?.randomUUID?.() ?? `attachment-${Date.now()}-${Math.random()}`;
+}

package/dist/components/agentic/attachments-preview.d.ts

@@ -0,0 +1,7 @@
+import type { AgenticPromptAttachmentStatus } from "./types";
+import type { AttachmentData, AttachmentMediaCategory, AttachmentVariant } from "./attachments-types";
+declare function renderAttachmentPreview(data: AttachmentData, mediaCategory: AttachmentMediaCategory, variant: AttachmentVariant): import("@types/react").JSX.Element | null;
+declare function AttachmentStatus({ status }: {
+    status?: AgenticPromptAttachmentStatus;
+}): import("@types/react").JSX.Element | null;
+export { AttachmentStatus, renderAttachmentPreview };

package/dist/components/agentic/attachments-preview.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* eslint-disable react-refresh/only-export-components */
+import { CheckIcon, CircleAlertIcon } from "lucide-react";
+import { getAttachmentLabel } from "./attachments-model";
+import { Spinner } from "@ciridae/ui/spinner";
+import { cn } from "@ciridae/ui/utils";
+function renderAttachmentPreview(data, mediaCategory, variant) {
+    if (mediaCategory === "image" && data.url) {
+        return (_jsx("img", { alt: getAttachmentLabel(data), className: cn("size-full object-cover", variant !== "grid" && "rounded"), height: variant === "grid" ? 96 : 20, src: data.url, width: variant === "grid" ? 96 : 20 }));
+    }
+    if (mediaCategory === "video" && data.url) {
+        return _jsx("video", { className: "size-full object-cover", muted: true, src: data.url });
+    }
+    return null;
+}
+function AttachmentStatus({ status }) {
+    if (status === "uploading")
+        return (_jsx(Spinner, { className: "size-3.5 shrink-0 text-muted-foreground", "data-slot": "attachment-status" }));
+    if (status === "complete")
+        return (_jsx(CheckIcon, { className: "size-3.5 shrink-0 text-muted-foreground", "data-slot": "attachment-status" }));
+    if (status === "error")
+        return (_jsx(CircleAlertIcon, { className: "size-3.5 shrink-0 text-destructive", "data-slot": "attachment-status" }));
+    return null;
+}
+export { AttachmentStatus, renderAttachmentPreview };

package/dist/components/agentic/attachments-types.d.ts

@@ -0,0 +1,87 @@
+import type * as React from "react";
+import type { AgenticPromptAttachment, AgenticPromptAttachmentKind } from "./types";
+import type { Button } from "@ciridae/ui/button";
+import type { HoverCard, HoverCardContent, HoverCardTrigger } from "@ciridae/ui/hover-card";
+export type AgenticAttachment = AgenticPromptAttachment & {
+    file?: File;
+    filename?: string;
+    title?: string;
+    type?: "file" | "source-document";
+};
+export type AttachmentData = AgenticAttachment;
+export type AttachmentMediaCategory = "image" | "video" | "audio" | "document" | "source" | "unknown";
+export type AttachmentVariant = "grid" | "inline" | "list";
+export type AttachmentErrorCode = "accept" | "max_attachments" | "max_attachment_size";
+export type AttachmentError = {
+    code: AttachmentErrorCode;
+    message: string;
+};
+export type AttachmentAddOptions = {
+    kind?: AgenticPromptAttachmentKind;
+};
+export type AttachmentScreenshotStatus = "idle" | "capturing" | "unavailable" | "error";
+export type AttachmentControllerContextValue = {
+    accept?: string;
+    add: (files: File[] | FileList, options?: AttachmentAddOptions) => void;
+    clear: () => void;
+    error?: AttachmentError;
+    files: AgenticAttachment[];
+    maxAttachmentSizeMb?: number;
+    maxAttachments?: number;
+    openFileDialog: () => void;
+    remove: (id: string) => void;
+    screenshotStatus: AttachmentScreenshotStatus;
+    takeScreenshot: () => Promise<void>;
+};
+export type AttachmentProviderProps = {
+    accept?: string;
+    attachments?: AgenticAttachment[];
+    children: React.ReactNode;
+    defaultAttachments?: AgenticAttachment[];
+    maxAttachmentSizeMb?: number;
+    maxAttachments?: number;
+    multiple?: boolean;
+    onAttachmentError?: (error: AttachmentError) => void;
+    onAttachmentsChange?: (attachments: AgenticAttachment[]) => void;
+    onCaptureScreenshot?: () => File | null | Promise<File | null>;
+};
+export type AttachmentsProps = React.ComponentProps<"div"> & {
+    variant?: AttachmentVariant;
+};
+export type AttachmentProps = React.ComponentProps<"div"> & {
+    attachment?: AttachmentData;
+    data?: AttachmentData;
+    onRemove?: () => void;
+};
+export type AttachmentPreviewProps = React.ComponentProps<"div"> & {
+    fallbackIcon?: React.ReactNode;
+};
+export type AttachmentInfoProps = React.ComponentProps<"div"> & {
+    showMediaType?: boolean;
+};
+export type AttachmentRemoveProps = React.ComponentProps<typeof Button> & {
+    attachmentId?: string;
+    label?: string;
+};
+export type AttachmentHoverCardProps = React.ComponentProps<typeof HoverCard>;
+export type AttachmentHoverCardTriggerProps = React.ComponentProps<typeof HoverCardTrigger>;
+export type AttachmentHoverCardContentProps = React.ComponentProps<typeof HoverCardContent>;
+export type AttachmentEmptyProps = React.ComponentProps<"div">;
+export type AttachmentListProps = AttachmentsProps;
+export type AttachmentNameProps = React.ComponentProps<"span">;
+export type AttachmentMetaProps = React.ComponentProps<"span"> & {
+    attachment?: AttachmentData;
+    data?: AttachmentData;
+};
+export type AttachmentActionRenderAs = "button" | "menu-item";
+export type AttachmentActionAddFilesProps = React.ComponentProps<typeof Button> & {
+    label?: string;
+    renderAs?: AttachmentActionRenderAs;
+    tooltip?: string;
+};
+export type AttachmentActionAddScreenshotProps = React.ComponentProps<typeof Button> & {
+    label?: string;
+    renderAs?: AttachmentActionRenderAs;
+    status?: AttachmentScreenshotStatus;
+    tooltip?: string;
+};

package/dist/components/agentic/attachments-types.js

@@ -0,0 +1 @@
+export {};

package/dist/components/agentic/attachments-ui.d.ts

@@ -0,0 +1,14 @@
+import * as React from "react";
+import type { AttachmentEmptyProps, AttachmentHoverCardContentProps, AttachmentHoverCardProps, AttachmentHoverCardTriggerProps, AttachmentInfoProps, AttachmentListProps, AttachmentMetaProps, AttachmentNameProps, AttachmentPreviewProps, AttachmentProps, AttachmentsProps } from "./attachments-types";
+declare function Attachments({ variant, className, children, ...props }: AttachmentsProps): React.JSX.Element | null;
+declare function AttachmentList({ variant, ...props }: AttachmentListProps): React.JSX.Element;
+declare function Attachment({ attachment, children, className, data, onRemove, ...props }: AttachmentProps): React.JSX.Element | null;
+declare function AttachmentPreview({ fallbackIcon, className, ...props }: AttachmentPreviewProps): React.JSX.Element;
+declare function AttachmentInfo({ showMediaType, className, ...props }: AttachmentInfoProps): React.JSX.Element | null;
+declare function AttachmentName({ className, children, ...props }: AttachmentNameProps): React.JSX.Element;
+declare function AttachmentMeta({ attachment, children, className, data, ...props }: AttachmentMetaProps): React.JSX.Element;
+declare function AttachmentHoverCard({ closeDelay, openDelay, ...props }: AttachmentHoverCardProps): React.JSX.Element;
+declare function AttachmentHoverCardTrigger(props: AttachmentHoverCardTriggerProps): React.JSX.Element;
+declare function AttachmentHoverCardContent({ align, className, ...props }: AttachmentHoverCardContentProps): React.JSX.Element;
+declare function AttachmentEmpty({ className, children, ...props }: AttachmentEmptyProps): React.JSX.Element;
+export { Attachment, AttachmentEmpty, AttachmentHoverCard, AttachmentHoverCardContent, AttachmentHoverCardTrigger, AttachmentInfo, AttachmentList, AttachmentMeta, AttachmentName, AttachmentPreview, Attachments, };