@jetcrab/pi-desk-sdk 0.0.0-stage → 1.0.1-dev.9001

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './capabilities.ts';
+export * from './shared.ts';
+export * from './settings.ts';
+export * from './errors.ts';
+export * from './entry.ts';
+export * from './session.ts';

package/dist/index.js

@@ -0,0 +1,6 @@
+export * from "./capabilities.js";
+export * from "./shared.js";
+export * from "./settings.js";
+export * from "./errors.js";
+export * from "./entry.js";
+export * from "./session.js";

package/dist/react-base.d.ts

@@ -0,0 +1,33 @@
+import { Component, type ErrorInfo, type ReactNode } from 'react';
+import type { BrowserConnectionHost, BrowserConnectionSnapshot, BrowserMessageHandle, BrowserPluginFacade, BrowserWorkSessionHost, PluginJsonObject, PluginPushMessage, PluginWorkSession, PublicMessageSnapshot } from './browser.js';
+export type { BrowserConnectionHost, BrowserConnectionSnapshot, BrowserMessageHandle, BrowserNotificationInput, BrowserNotificationLevel, BrowserPluginFacade, BrowserWorkSessionHost, PluginPushMessage, PluginWorkSession, PublicMessageSnapshot } from './browser.js';
+export * from './react-ui.tsx';
+export * from './react-log.tsx';
+export declare function usePluginConnection(connection: BrowserConnectionHost): BrowserConnectionSnapshot;
+export declare function usePluginWorkSessions(workSessions: BrowserWorkSessionHost): readonly PluginWorkSession[];
+export declare function usePluginPush(plugin: Pick<BrowserPluginFacade, 'onPush'>, listener: (message: PluginPushMessage) => void): void;
+export declare function useMessageHandle(handle: BrowserMessageHandle): PublicMessageSnapshot;
+export interface MessageDetailState {
+    detail: PluginJsonObject | null | undefined;
+    loading: boolean;
+    error: Error | null;
+    load(): Promise<PluginJsonObject | null>;
+}
+export declare function useMessageDetail(handle: BrowserMessageHandle, autoLoad?: boolean): MessageDetailState;
+export interface PluginErrorBoundaryProps {
+    children: ReactNode;
+    fallback?: ReactNode | ((error: Error, retry: () => void) => ReactNode);
+    onError?(error: Error, info: ErrorInfo): void;
+    resetKey?: unknown;
+}
+interface PluginErrorBoundaryState {
+    error: Error | null;
+}
+export declare class PluginErrorBoundary extends Component<PluginErrorBoundaryProps, PluginErrorBoundaryState> {
+    state: PluginErrorBoundaryState;
+    static getDerivedStateFromError(error: Error): PluginErrorBoundaryState;
+    componentDidCatch(error: Error, info: ErrorInfo): void;
+    componentDidUpdate(previousProps: PluginErrorBoundaryProps): void;
+    private readonly retry;
+    render(): ReactNode;
+}

package/dist/react-base.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Component, useCallback, useEffect, useRef, useState, useSyncExternalStore } from 'react';
+export * from "./react-ui.js";
+export * from "./react-log.js";
+function useExternalSnapshot(owner) {
+    const subscribe = useCallback((listener) => {
+        const dispose = owner.subscribe(listener);
+        return () => {
+            void dispose();
+        };
+    }, [owner]);
+    const getSnapshot = useCallback(() => owner.getSnapshot(), [owner]);
+    return useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+}
+export function usePluginConnection(connection) {
+    return useExternalSnapshot(connection);
+}
+export function usePluginWorkSessions(workSessions) {
+    return useExternalSnapshot(workSessions);
+}
+export function usePluginPush(plugin, listener) {
+    useEffect(() => {
+        const dispose = plugin.onPush(listener);
+        return () => {
+            void dispose();
+        };
+    }, [listener, plugin]);
+}
+export function useMessageHandle(handle) {
+    return useExternalSnapshot(handle);
+}
+export function useMessageDetail(handle, autoLoad = false) {
+    const snapshot = useMessageHandle(handle);
+    const requestEpoch = useRef(0);
+    const [requestState, setRequestState] = useState({ handle, loading: false, loaded: false, error: null });
+    const currentState = requestState.handle === handle
+        ? requestState
+        : { handle, loading: false, loaded: false, error: null };
+    const load = useCallback(async () => {
+        const epoch = requestEpoch.current + 1;
+        requestEpoch.current = epoch;
+        setRequestState({ handle, loading: true, loaded: false, error: null });
+        try {
+            const detail = await handle.loadDetail();
+            if (requestEpoch.current === epoch) {
+                setRequestState({ handle, loading: false, loaded: true, error: null });
+            }
+            return detail;
+        }
+        catch (cause) {
+            const nextError = cause instanceof Error ? cause : new Error(String(cause));
+            if (requestEpoch.current === epoch) {
+                setRequestState({ handle, loading: false, loaded: false, error: nextError });
+            }
+            throw nextError;
+        }
+    }, [handle]);
+    useEffect(() => {
+        if (!autoLoad ||
+            currentState.loading ||
+            currentState.loaded ||
+            currentState.error ||
+            snapshot.detail !== undefined ||
+            !snapshot.fixed.hasDetail ||
+            !('entryId' in snapshot.location)) {
+            return;
+        }
+        let active = true;
+        queueMicrotask(() => {
+            if (active)
+                void load().catch(() => undefined);
+        });
+        return () => {
+            active = false;
+        };
+    }, [
+        autoLoad,
+        currentState.error,
+        currentState.loaded,
+        currentState.loading,
+        load,
+        snapshot.detail,
+        snapshot.fixed.hasDetail,
+        snapshot.location
+    ]);
+    return {
+        detail: snapshot.detail,
+        loading: currentState.loading,
+        error: currentState.error,
+        load
+    };
+}
+export class PluginErrorBoundary extends Component {
+    state = { error: null };
+    static getDerivedStateFromError(error) {
+        return { error };
+    }
+    componentDidCatch(error, info) {
+        this.props.onError?.(error, info);
+    }
+    componentDidUpdate(previousProps) {
+        if (previousProps.resetKey !== this.props.resetKey && this.state.error) {
+            this.setState({ error: null });
+        }
+    }
+    retry = () => {
+        this.setState({ error: null });
+    };
+    render() {
+        const { error } = this.state;
+        if (!error)
+            return this.props.children;
+        if (typeof this.props.fallback === 'function') {
+            return this.props.fallback(error, this.retry);
+        }
+        if (this.props.fallback !== undefined)
+            return this.props.fallback;
+        return (_jsxs("div", { role: "alert", "data-pi-desk-plugin-error": "true", children: [_jsx("p", { children: "\u63D2\u4EF6\u754C\u9762\u52A0\u8F7D\u5931\u8D25" }), _jsx("pre", { children: error.message }), _jsx("button", { type: "button", onClick: this.retry, children: "\u91CD\u8BD5" })] }));
+    }
+}

package/dist/react-log.d.ts

@@ -0,0 +1,12 @@
+import { type HTMLAttributes, type ReactNode } from 'react';
+import type { BrowserPluginHost } from './browser.js';
+export interface PluginHostProviderProps {
+    host: BrowserPluginHost;
+    children: ReactNode;
+}
+export declare function PluginHostProvider({ host, children }: PluginHostProviderProps): React.JSX.Element;
+export declare function usePluginHost(): BrowserPluginHost;
+export interface PluginLogViewerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    path: string;
+}
+export declare function PluginLogViewer(props: PluginLogViewerProps): React.JSX.Element;

package/dist/react-log.js

@@ -0,0 +1,99 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useRef, useState } from 'react';
+import { PluginButton, PluginScroll, PluginSurface } from "./react-ui.js";
+const PluginHostContext = createContext(null);
+const EMPTY_LOG_SNAPSHOT = {
+    text: '',
+    truncated: false,
+    loading: true,
+    error: null
+};
+const PLUGIN_LOG_STYLES = `
+.pi-desk-ui-log{position:relative;display:flex;min-width:0;height:18rem;max-height:min(18rem,50dvh);flex-direction:column;overflow:hidden;border:1px solid var(--pi-desk-plugin-border,var(--border));border-radius:.5rem;background:var(--pi-desk-plugin-background,var(--background));color:var(--pi-desk-plugin-foreground,var(--foreground))}
+.pi-desk-ui-log-status{display:flex;min-height:2rem;flex-shrink:0;align-items:center;justify-content:space-between;gap:.75rem;border-bottom:1px solid var(--pi-desk-plugin-border,var(--border));padding:.35rem .65rem;color:var(--pi-desk-plugin-muted-foreground,var(--muted-foreground));font-size:.75rem;line-height:1.5}
+.pi-desk-ui-log-scroll{min-height:0;flex:1}
+.pi-desk-ui-log-scroll-viewport{padding:.75rem;overscroll-behavior:contain}
+.pi-desk-ui-log-content{margin:0;min-width:100%;font:.875rem/1.6 ui-monospace,SFMono-Regular,Consolas,monospace;white-space:pre-wrap;overflow-wrap:anywhere}
+.pi-desk-ui-log-empty{display:grid;min-height:100%;place-items:center;padding:1rem;color:var(--pi-desk-plugin-muted-foreground,var(--muted-foreground));font-size:.875rem;text-align:center}
+.pi-desk-ui-log-error{display:flex;flex-shrink:0;align-items:center;justify-content:space-between;gap:.75rem;border-top:1px solid color-mix(in srgb,var(--pi-desk-plugin-destructive,var(--destructive)) 35%,var(--pi-desk-plugin-border,var(--border)));padding:.45rem .65rem;background:color-mix(in srgb,var(--pi-desk-plugin-destructive,var(--destructive)) 8%,transparent);color:var(--pi-desk-plugin-destructive,var(--destructive));font-size:.75rem}
+.pi-desk-ui-log-bottom{position:absolute;right:.65rem;bottom:.65rem;box-shadow:0 4px 16px color-mix(in srgb,var(--pi-desk-plugin-foreground,var(--foreground)) 16%,transparent)}
+@media(max-width:640px){.pi-desk-ui-log{height:14rem;max-height:45dvh}.pi-desk-ui-log-scroll-viewport{padding:.65rem}}
+`;
+function classNames(...values) {
+    return values.filter(Boolean).join(' ');
+}
+export function PluginHostProvider({ host, children }) {
+    return _jsx(PluginHostContext.Provider, { value: host, children: children });
+}
+export function usePluginHost() {
+    const host = useContext(PluginHostContext);
+    if (!host)
+        throw new Error('PluginLogViewer 必须位于 PluginHostProvider 内');
+    return host;
+}
+function usePluginLog(path) {
+    const host = usePluginHost();
+    const handleRef = useRef(null);
+    const [state, setState] = useState({
+        path,
+        snapshot: EMPTY_LOG_SNAPSHOT
+    });
+    useEffect(() => {
+        const handle = host.logs.open(path);
+        handleRef.current = { path, handle };
+        const update = () => {
+            setState({ path, snapshot: handle.getSnapshot() });
+        };
+        update();
+        const unsubscribe = handle.subscribe(update);
+        return () => {
+            unsubscribe();
+            handle.dispose();
+            if (handleRef.current?.handle === handle)
+                handleRef.current = null;
+        };
+    }, [host.logs, path]);
+    return {
+        snapshot: state.path === path ? state.snapshot : EMPTY_LOG_SNAPSHOT,
+        retry: () => {
+            const current = handleRef.current;
+            if (current?.path === path)
+                current.handle.retry();
+        }
+    };
+}
+function PluginLogViewerContent({ path, className, ...props }) {
+    const { snapshot, retry } = usePluginLog(path);
+    const scrollRef = useRef(null);
+    const followRef = useRef(true);
+    const [following, setFollowing] = useState(true);
+    const scrollToBottom = useCallback(() => {
+        const element = scrollRef.current;
+        if (!element)
+            return;
+        element.scrollTop = element.scrollHeight;
+        followRef.current = true;
+        setFollowing(true);
+    }, []);
+    useEffect(() => {
+        if (followRef.current)
+            scrollToBottom();
+    }, [scrollToBottom, snapshot.text]);
+    const handleScroll = () => {
+        const element = scrollRef.current;
+        if (!element)
+            return;
+        const atBottom = element.scrollHeight - element.scrollTop - element.clientHeight <= 24;
+        followRef.current = atBottom;
+        setFollowing(atBottom);
+    };
+    const status = snapshot.truncated
+        ? '日志较长，当前仅显示末尾内容'
+        : snapshot.loading && snapshot.text
+            ? '正在同步日志…'
+            : null;
+    return (_jsxs(PluginSurface, { ...props, "data-pi-desk-plugin-log-viewer": "", className: classNames('pi-desk-ui-log', className), children: [_jsx("style", { children: PLUGIN_LOG_STYLES }), status ? (_jsx("div", { className: "pi-desk-ui-log-status", role: "status", children: _jsx("span", { children: status }) })) : null, _jsx(PluginScroll, { viewportRef: scrollRef, className: "pi-desk-ui-log-scroll", viewportClassName: "pi-desk-ui-log-scroll-viewport", onScroll: handleScroll, children: snapshot.text ? (_jsx("pre", { className: "pi-desk-ui-log-content", children: snapshot.text })) : (_jsx("div", { className: "pi-desk-ui-log-empty", role: "status", children: snapshot.loading ? '正在加载日志…' : '等待日志输出…' })) }), snapshot.error ? (_jsxs("div", { className: "pi-desk-ui-log-error", role: "alert", children: [_jsx("span", { children: snapshot.error }), _jsx(PluginButton, { size: "sm", onClick: retry, children: "\u91CD\u8BD5" })] })) : null, !following && snapshot.text ? (_jsx(PluginButton, { size: "sm", className: "pi-desk-ui-log-bottom", onClick: scrollToBottom, children: "\u56DE\u5230\u5E95\u90E8" })) : null] }));
+}
+export function PluginLogViewer(props) {
+    return _jsx(PluginLogViewerContent, { ...props }, props.path);
+}

package/dist/react-markdown.d.ts

@@ -0,0 +1,5 @@
+export interface PluginMarkdownProps {
+    content: string;
+    className?: string;
+}
+export declare function PluginMarkdown({ content, className }: PluginMarkdownProps): React.JSX.Element;

package/dist/react-markdown.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cjk } from '@streamdown/cjk';
+import { Streamdown } from 'streamdown';
+const PLUGIN_MARKDOWN_PLUGINS = { cjk };
+const COMPACT_CODE_CONTROLS = {
+    code: {
+        copy: true,
+        download: false
+    }
+};
+function classNames(...values) {
+    return values.filter(Boolean).join(' ');
+}
+export function PluginMarkdown({ content, className }) {
+    return (_jsx(Streamdown, { className: classNames('pi-desk-ui-markdown space-y-0', className), controls: COMPACT_CODE_CONTROLS, lineNumbers: false, plugins: PLUGIN_MARKDOWN_PLUGINS, children: content }));
+}

package/dist/react-ui.d.ts

@@ -0,0 +1,197 @@
+import { ContextMenu as ContextMenuPrimitive } from '@base-ui/react/context-menu';
+import { type ButtonHTMLAttributes, type HTMLAttributes, type InputHTMLAttributes, type ReactNode, type Ref, type SelectHTMLAttributes, type TextareaHTMLAttributes, type UIEventHandler } from 'react';
+export declare function PluginSurface({ className, children, ...props }: HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+export type PluginScrollOrientation = 'vertical' | 'horizontal' | 'both';
+export type PluginScrollProps = Omit<HTMLAttributes<HTMLDivElement>, 'onScroll'> & {
+    orientation?: PluginScrollOrientation;
+    viewportClassName?: string;
+    viewportRef?: Ref<HTMLDivElement>;
+    onScroll?: UIEventHandler<HTMLDivElement>;
+};
+export declare function PluginScroll({ orientation, viewportClassName, viewportRef, onScroll, role, className, children, ...props }: PluginScrollProps): React.JSX.Element;
+export type PluginDensity = 'regular' | 'compact';
+export type PluginControlSize = 'default' | 'sm';
+type PluginHeadingLevel = 1 | 2 | 3 | 4;
+export interface PluginPanelHeaderProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    title: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    meta?: ReactNode;
+    density?: PluginDensity;
+    headingLevel?: PluginHeadingLevel;
+}
+export declare function PluginPanelHeader({ title, description, actions, meta, density, headingLevel, className, ...props }: PluginPanelHeaderProps): React.JSX.Element;
+export interface PluginSectionProps extends Omit<HTMLAttributes<HTMLElement>, 'title'> {
+    title: ReactNode;
+    description?: ReactNode;
+    action?: ReactNode;
+    density?: PluginDensity;
+    headingLevel?: PluginHeadingLevel;
+}
+export declare function PluginSection({ title, description, action, density, headingLevel, className, children, ...props }: PluginSectionProps): React.JSX.Element;
+export interface PluginTabListProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+}
+export declare function PluginTabList({ label, className, ...props }: PluginTabListProps): React.JSX.Element;
+export interface PluginTabProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    active?: boolean;
+}
+export declare function PluginTab({ active, className, type, ...props }: PluginTabProps): React.JSX.Element;
+export type PluginActionRowAlign = 'start' | 'end' | 'between';
+export interface PluginActionRowProps extends HTMLAttributes<HTMLDivElement> {
+    align?: PluginActionRowAlign;
+    mobileStack?: boolean;
+}
+export declare function PluginActionRow({ align, mobileStack, className, ...props }: PluginActionRowProps): React.JSX.Element;
+export type PluginKeyValueLayout = 'inline' | 'stacked';
+export interface PluginKeyValueListProps extends HTMLAttributes<HTMLDListElement> {
+    density?: PluginDensity;
+    layout?: PluginKeyValueLayout;
+}
+export declare function PluginKeyValueList({ density, layout, className, ...props }: PluginKeyValueListProps): React.JSX.Element;
+export interface PluginKeyValueItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    label: ReactNode;
+    value: ReactNode;
+    action?: ReactNode;
+}
+export declare function PluginKeyValueItem({ label, value, action, className, ...props }: PluginKeyValueItemProps): React.JSX.Element;
+export declare function PluginSpinner({ className }: {
+    className?: string;
+}): React.JSX.Element;
+export interface PluginLoadingStateProps {
+    loading: boolean;
+    error?: Error | string | null;
+    loadingLabel?: ReactNode;
+    retryLabel?: ReactNode;
+    onRetry?: () => void;
+    className?: string;
+    children: ReactNode;
+}
+export declare function PluginLoadingState({ loading, error, loadingLabel, retryLabel, onRetry, className, children }: PluginLoadingStateProps): React.JSX.Element;
+export interface PluginSplitViewProps extends HTMLAttributes<HTMLDivElement> {
+    navigation: ReactNode;
+    navigationLabel?: string;
+}
+export declare function PluginSplitView({ navigation, navigationLabel, className, children, ...props }: PluginSplitViewProps): React.JSX.Element;
+export interface PluginListProps extends HTMLAttributes<HTMLDivElement> {
+    density?: PluginDensity;
+}
+export declare function PluginList({ density, className, ...props }: PluginListProps): React.JSX.Element;
+export interface PluginListItemProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    selected?: boolean;
+    density?: PluginDensity;
+}
+export declare function PluginListItem({ selected, density, className, type, ...props }: PluginListItemProps): React.JSX.Element;
+export interface PluginCardProps extends HTMLAttributes<HTMLDivElement> {
+    density?: PluginDensity;
+}
+export declare function PluginCard({ density, className, ...props }: PluginCardProps): React.JSX.Element;
+export type PluginButtonVariant = 'primary' | 'secondary' | 'danger' | 'ghost';
+export type PluginButtonSize = 'default' | 'sm' | 'xs';
+export interface PluginButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: PluginButtonVariant;
+    size?: PluginButtonSize;
+}
+export declare function PluginButton({ variant, size, className, type, ...props }: PluginButtonProps): React.JSX.Element;
+export declare function PluginContextMenu(props: ContextMenuPrimitive.Root.Props): React.JSX.Element;
+export declare function PluginContextMenuTrigger(props: ContextMenuPrimitive.Trigger.Props): React.JSX.Element;
+export type PluginContextMenuContentProps = Omit<ContextMenuPrimitive.Popup.Props, 'className'> & {
+    className?: string;
+};
+export declare function PluginContextMenuContent({ className, ...props }: PluginContextMenuContentProps): React.JSX.Element;
+export type PluginContextMenuItemProps = Omit<ContextMenuPrimitive.Item.Props, 'className'> & {
+    className?: string;
+};
+export declare function PluginContextMenuItem({ className, ...props }: PluginContextMenuItemProps): React.JSX.Element;
+export type PluginBadgeTone = 'neutral' | 'info' | 'success' | 'warning' | 'error';
+export interface PluginBadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: PluginBadgeTone;
+}
+export declare function PluginBadge({ tone, className, ...props }: PluginBadgeProps): React.JSX.Element;
+export type PluginAlertTone = 'neutral' | 'info' | 'warning' | 'error';
+export interface PluginAlertProps extends HTMLAttributes<HTMLDivElement> {
+    tone?: PluginAlertTone;
+    density?: PluginDensity;
+}
+export declare function PluginAlert({ tone, density, className, ...props }: PluginAlertProps): React.JSX.Element;
+export type PluginDialogSize = 'sm' | 'md' | 'lg';
+export interface PluginDialogProps {
+    open: boolean;
+    title: ReactNode;
+    description?: ReactNode;
+    size?: PluginDialogSize;
+    footer?: ReactNode;
+    closeLabel?: string;
+    children: ReactNode;
+    onOpenChange(open: boolean): void;
+}
+export declare function PluginDialog({ open, title, description, size, footer, closeLabel, children, onOpenChange }: PluginDialogProps): React.JSX.Element;
+export interface PluginConfirmDialogProps {
+    open: boolean;
+    title: ReactNode;
+    description?: ReactNode;
+    confirmLabel: ReactNode;
+    cancelLabel?: ReactNode;
+    tone?: 'default' | 'danger';
+    pending?: boolean;
+    children?: ReactNode;
+    onConfirm(): void | Promise<void>;
+    onOpenChange(open: boolean): void;
+}
+export declare function PluginConfirmDialog({ open, title, description, confirmLabel, cancelLabel, tone, pending, children, onConfirm, onOpenChange }: PluginConfirmDialogProps): React.JSX.Element;
+export interface PluginEmptyStateProps extends HTMLAttributes<HTMLDivElement> {
+    density?: PluginDensity;
+}
+export declare function PluginEmptyState({ density, className, ...props }: PluginEmptyStateProps): React.JSX.Element;
+export interface PluginFieldProps extends HTMLAttributes<HTMLDivElement> {
+    label: ReactNode;
+    htmlFor?: string;
+    description?: ReactNode;
+    error?: ReactNode;
+    density?: PluginDensity;
+}
+export declare function PluginField({ label, htmlFor, description, error, density, className, children, ...props }: PluginFieldProps): React.JSX.Element;
+export interface PluginInputProps extends InputHTMLAttributes<HTMLInputElement> {
+    controlSize?: PluginControlSize;
+}
+export declare function PluginInput({ controlSize, className, ...props }: PluginInputProps): React.JSX.Element;
+export type PluginCheckboxProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'type'>;
+export declare function PluginCheckbox({ className, ...props }: PluginCheckboxProps): React.JSX.Element;
+export type PluginSecretInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'autoComplete' | 'autoCapitalize' | 'spellCheck'> & {
+    controlSize?: PluginControlSize;
+};
+export declare function PluginSecretInput({ controlSize, className, disabled, id, ...props }: PluginSecretInputProps): React.JSX.Element;
+export interface PluginSelectProps extends SelectHTMLAttributes<HTMLSelectElement> {
+    controlSize?: PluginControlSize;
+}
+export declare function PluginSelect({ controlSize, className, ...props }: PluginSelectProps): React.JSX.Element;
+export interface PluginSelectOption {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+    textValue?: string;
+}
+export interface PluginSelectFieldProps {
+    id?: string;
+    name?: string;
+    label: ReactNode;
+    description?: ReactNode;
+    error?: ReactNode;
+    value?: string | null;
+    defaultValue?: string | null;
+    options: readonly PluginSelectOption[];
+    placeholder?: ReactNode;
+    disabled?: boolean;
+    required?: boolean;
+    size?: PluginControlSize;
+    className?: string;
+    triggerClassName?: string;
+    popupClassName?: string;
+    onValueChange?: (value: string | null) => void;
+}
+export declare function PluginSelectField({ id, name, label, description, error, value, defaultValue, options, placeholder, disabled, required, size, className, triggerClassName, popupClassName, onValueChange }: PluginSelectFieldProps): React.JSX.Element;
+export interface PluginTextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    controlSize?: PluginControlSize;
+}
+export declare function PluginTextarea({ controlSize, className, ...props }: PluginTextareaProps): React.JSX.Element;
+export {};