import * as react_jsx_runtime from 'react/jsx-runtime';
import { AgentWorkbenchQuickStartViewModel, AgentWorkbenchNavigationViewModel, AgentWorkbenchSidebarConfig, AgentWorkbenchSessionItem, AgentSessionViewModel, AgentSessionEvent, AgentSessionCapabilities } from '@inf-monkeys-tech/monkeys';
import * as React from 'react';
import { ReactNode, HTMLAttributes, ReactEventHandler } from 'react';
type AgentWorkbenchVariant = "default" | "trend";
type AgentWorkbenchDensity = "compact" | "default";
type AgentWorkbenchSurfaceLevel = "elevated" | "overlay" | "page" | "panel" | "subtle";
interface AgentWorkbenchAppearance {
    variant: AgentWorkbenchVariant;
    density: AgentWorkbenchDensity;
}
interface AgentWorkbenchAppearanceOptions {
    variant?: AgentWorkbenchVariant;
    density?: AgentWorkbenchDensity;
}
declare function resolveAgentWorkbenchAppearance(inherited: AgentWorkbenchAppearance, options?: AgentWorkbenchAppearanceOptions): AgentWorkbenchAppearance;
interface AgentWorkbenchAppearanceProviderProps extends AgentWorkbenchAppearanceOptions {
    children: ReactNode;
}
declare function AgentWorkbenchAppearanceProvider({ children, variant, density, }: AgentWorkbenchAppearanceProviderProps): react_jsx_runtime.JSX.Element;
interface AgentWorkbenchSurfaceProps extends HTMLAttributes<HTMLDivElement>, AgentWorkbenchAppearanceOptions {
    level?: AgentWorkbenchSurfaceLevel;
}
/** Semantic surface primitive shared by Agent workbench regions and overlays. */
declare const AgentWorkbenchSurface: React.ForwardRefExoticComponent<AgentWorkbenchSurfaceProps & React.RefAttributes<HTMLDivElement>>;
type AgentWorkbenchQuickStartIntent = {
    type: 'change-category';
    categoryId?: string;
} | {
    type: 'change-section';
    categoryId: string;
    sectionId: string;
} | {
    type: 'select-template';
    templateId: string;
    prompt: string;
    files?: File[];
};
interface AgentWorkbenchQuickStartProps {
    viewModel: AgentWorkbenchQuickStartViewModel;
    className?: string;
    onIntent?: (intent: AgentWorkbenchQuickStartIntent) => void;
}
declare function AgentWorkbenchQuickStart({ viewModel, className, onIntent }: AgentWorkbenchQuickStartProps): null | react_jsx_runtime.JSX.Element;
type AgentWorkbenchSidebarIntent = {
    type: 'change-search';
    query: string;
} | {
    type: 'change-tab';
    tab: 'agents' | 'sessions';
} | {
    type: 'create-agent';
} | {
    type: 'create-session';
} | {
    type: 'delete-session';
    sessionId: string;
} | {
    type: 'open-agent-settings';
} | {
    type: 'open-capabilities';
} | {
    type: 'rename-session';
    sessionId: string;
    title: string;
} | {
    type: 'retry-agents';
} | {
    type: 'retry-sessions';
} | {
    type: 'select-agent';
    itemId: string;
} | {
    type: 'select-session';
    sessionId: string;
} | {
    type: 'toggle-agent-pin';
    itemId: string;
    pinned: boolean;
} | {
    type: 'toggle-session-pin';
    sessionId: string;
    pinned: boolean;
};
interface AgentWorkbenchSidebarClassNames {
    root?: string;
    search?: string;
    tabs?: string;
    body?: string;
    item?: string;
    footer?: string;
}
interface AgentWorkbenchSidebarProps {
    viewModel: AgentWorkbenchNavigationViewModel;
    navigationMode?: 'agents-and-sessions' | 'sessions-only';
    config?: AgentWorkbenchSidebarConfig;
    header?: ReactNode;
    headerActions?: ReactNode;
    footer?: ReactNode;
    className?: string;
    classNames?: AgentWorkbenchSidebarClassNames;
    onIntent?: (intent: AgentWorkbenchSidebarIntent) => void;
}
declare function AgentWorkbenchSidebar({ viewModel, navigationMode, config, header, headerActions, footer, className, classNames, onIntent, }: AgentWorkbenchSidebarProps): react_jsx_runtime.JSX.Element;
interface AgentWorkbenchSidebarContainerClassNames {
    root?: string;
    header?: string;
    search?: string;
    primaryAction?: string;
    actions?: string;
    body?: string;
    groups?: string;
    footer?: string;
}
interface AgentWorkbenchSidebarContainerBodyProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "className"> {
    "data-agent-workbench-session-scroll-region"?: "" | boolean;
}
interface AgentWorkbenchSidebarContainerProps extends Omit<HTMLAttributes<HTMLElement>, "children" | "className">, AgentWorkbenchAppearanceOptions {
    children?: ReactNode;
    header?: ReactNode;
    search?: ReactNode;
    primaryAction?: ReactNode;
    actions?: ReactNode;
    groups?: ReactNode;
    footer?: ReactNode;
    className?: string;
    classNames?: AgentWorkbenchSidebarContainerClassNames;
    bodyProps?: AgentWorkbenchSidebarContainerBodyProps;
    bodyScrollable?: boolean;
    status?: "empty" | "error" | "loading" | "ready";
    loadingState?: ReactNode;
    emptyState?: ReactNode;
    errorState?: ReactNode;
}
/** Shared structural shell for agent navigation variants. Product data stays in the slots. */
declare const AgentWorkbenchSidebarContainer: React.ForwardRefExoticComponent<AgentWorkbenchSidebarContainerProps & React.RefAttributes<HTMLElement>>;
interface AgentWorkbenchExploreItem {
    id: string;
    title: string;
    imageUrl?: string;
    subtitle?: string;
    mediaVariant?: AgentWorkbenchExploreMediaVariant;
    mediaTreatment?: AgentWorkbenchExploreMediaTreatment;
}
type AgentWorkbenchExploreMediaVariant = "cover-with-label" | "cover" | "logo";
type AgentWorkbenchExploreMediaTreatment = "invert" | "monochrome-light" | "preserve";
interface AgentWorkbenchExploreCardMediaProps {
    item: AgentWorkbenchExploreItem;
    src?: string;
    className?: string;
    onError?: ReactEventHandler<HTMLImageElement>;
}
interface AgentWorkbenchExploreGroup {
    id: string;
    label: string;
    items: AgentWorkbenchExploreItem[];
    itemAspectRatio?: number;
}
interface AgentWorkbenchExploreSidebarLabels {
    navigation: string;
    search: string;
    newSession: string;
    draftSession: string;
    emptySessions: string;
    noResults: string;
    retry?: string;
}
type AgentWorkbenchExploreSidebarIntent = {
    type: "change-group";
    groupId: string;
} | {
    type: "change-search";
    query: string;
} | {
    type: "create-session";
} | {
    type: "delete-session";
    sessionId: string;
} | {
    type: "retry-sessions";
} | {
    type: "select-item";
    groupId: string;
    item: AgentWorkbenchExploreItem;
} | {
    type: "select-session";
    sessionId: string;
};
interface AgentWorkbenchExploreSidebarProps {
    sessions: AgentWorkbenchSessionItem[];
    groups?: AgentWorkbenchExploreGroup[];
    config?: AgentWorkbenchSidebarConfig;
    labels: AgentWorkbenchExploreSidebarLabels;
    selectedSessionId?: string;
    searchQuery?: string;
    loading?: boolean;
    error?: string;
    showDraftSession?: boolean;
    deleteSessions?: boolean;
    /** Uses the compact session list treatment for trend workbenches. */
    variant?: AgentWorkbenchVariant;
    defaultGroupId?: string;
    header?: ReactNode;
    footer?: ReactNode;
    className?: string;
    renderItemMedia?: (item: AgentWorkbenchExploreItem, group: AgentWorkbenchExploreGroup) => ReactNode;
    onIntent?: (intent: AgentWorkbenchExploreSidebarIntent) => void;
}
declare function AgentWorkbenchExploreCardMedia({ item, src, className, onError, }: AgentWorkbenchExploreCardMediaProps): null | react_jsx_runtime.JSX.Element;
declare function AgentWorkbenchExploreSidebar({ sessions, groups: configuredGroups, config, labels, selectedSessionId, searchQuery, loading, error, showDraftSession, deleteSessions, variant, defaultGroupId, header, footer, className, renderItemMedia, onIntent, }: AgentWorkbenchExploreSidebarProps): react_jsx_runtime.JSX.Element;
type SessionEventType = AgentSessionEvent['eventType'];
type AgentWorkbenchEventOf<Type extends SessionEventType> = Extract<AgentSessionEvent, {
    eventType: Type;
}>;
interface AgentWorkbenchActivityModel {
    mode: AgentSessionViewModel['snapshot']['mode'];
    status: AgentSessionViewModel['status'];
    reasoning: AgentWorkbenchEventOf<'reasoning'>[];
    plans: AgentWorkbenchEventOf<'plan'>[];
    tasks: AgentWorkbenchEventOf<'task'>[];
    tools: AgentWorkbenchEventOf<'tool'>[];
    approvals: AgentWorkbenchEventOf<'approval'>[];
    artifacts: AgentWorkbenchEventOf<'artifact'>[];
    usage?: AgentWorkbenchEventOf<'usage'>;
    run?: AgentWorkbenchEventOf<'status'> & {
        resolvedDurationMs?: number;
    };
}
declare function createAgentWorkbenchActivityModel(viewModel: AgentSessionViewModel): AgentWorkbenchActivityModel;
type AgentWorkbenchApprovalData = AgentWorkbenchEventOf<"approval">["payload"];
interface AgentWorkbenchApprovalIntent {
    approvalId: string;
    approved: boolean;
}
interface AgentWorkbenchApprovalProps {
    approval: AgentWorkbenchApprovalData;
    className?: string;
    onDecision?: (intent: AgentWorkbenchApprovalIntent) => void;
}
declare function AgentWorkbenchApproval({ approval, className, onDecision, }: AgentWorkbenchApprovalProps): react_jsx_runtime.JSX.Element;
interface AgentWorkbenchArtifactIntent {
    artifactId: string;
    name: string;
    url: string;
}
interface AgentWorkbenchActivityClassNames {
    root?: string;
    item?: string;
    trigger?: string;
    content?: string;
    approval?: string;
    artifact?: string;
    usage?: string;
}
interface AgentWorkbenchActivityProps {
    viewModel?: AgentSessionViewModel;
    ariaLabel?: string;
    hiddenToolCallIds?: ReadonlySet<string>;
    hideReasoning?: boolean;
    hideStoppedRun?: boolean;
    className?: string;
    classNames?: AgentWorkbenchActivityClassNames;
    onApprovalDecision?: (intent: AgentWorkbenchApprovalIntent) => void;
    onArtifactOpen?: (intent: AgentWorkbenchArtifactIntent) => void;
}
declare function AgentWorkbenchActivity({ viewModel, ariaLabel, hiddenToolCallIds, hideReasoning, hideStoppedRun, className, classNames, onApprovalDecision, onArtifactOpen, }: AgentWorkbenchActivityProps): null | react_jsx_runtime.JSX.Element;
type AgentWorkbenchDetailsTab = 'summary' | 'workspace';
type AgentWorkbenchDetailsState = 'empty' | 'error' | 'loading' | 'ready';
type AgentWorkbenchDetailsIntent = {
    type: 'close';
} | {
    type: 'continue-in-new-task';
    sessionId: string;
} | {
    type: 'copy-summary';
    summaryId: string;
    text: string;
} | {
    type: 'edit-and-rerun';
    sessionId: string;
} | {
    type: 'export';
    sessionId: string;
} | {
    type: 'resume';
    sessionId: string;
} | {
    type: 'retry-summary';
    eventId: string;
} | {
    type: 'retry';
    eventId: string;
};
interface AgentWorkbenchTaskDetailsClassNames {
    root?: string;
    header?: string;
    tabs?: string;
    body?: string;
    section?: string;
    code?: string;
}
interface AgentWorkbenchTaskDetailsProps {
    viewModel?: AgentSessionViewModel;
    state?: AgentWorkbenchDetailsState;
    activeTab?: AgentWorkbenchDetailsTab;
    className?: string;
    classNames?: AgentWorkbenchTaskDetailsClassNames;
    onActiveTabChange?: (tab: AgentWorkbenchDetailsTab) => void;
    onIntent?: (intent: AgentWorkbenchDetailsIntent) => void;
    onExport?: (intent: Extract<AgentWorkbenchDetailsIntent, {
        type: 'export';
    }>) => void;
    onCopySummary?: (intent: Extract<AgentWorkbenchDetailsIntent, {
        type: 'copy-summary';
    }>) => void;
    onRetry?: (intent: Extract<AgentWorkbenchDetailsIntent, {
        type: 'retry';
    }>) => void;
    onRetrySummary?: (intent: Extract<AgentWorkbenchDetailsIntent, {
        type: 'retry-summary';
    }>) => void;
}
declare function AgentWorkbenchTaskDetails({ viewModel, state, activeTab, className, classNames, onActiveTabChange, onIntent, onExport, onCopySummary, onRetry, onRetrySummary, }: AgentWorkbenchTaskDetailsProps): react_jsx_runtime.JSX.Element;
interface AgentWorkbenchToolClassNames {
    root?: string;
    trigger?: string;
    content?: string;
    input?: string;
    output?: string;
}
interface AgentWorkbenchToolProps {
    event: AgentWorkbenchEventOf<'tool'>;
    expanded?: boolean;
    defaultExpanded?: boolean;
    className?: string;
    classNames?: AgentWorkbenchToolClassNames;
    onExpandedChange?: (expanded: boolean) => void;
}
declare function AgentWorkbenchTool({ event, expanded, defaultExpanded, className, classNames, onExpandedChange, }: AgentWorkbenchToolProps): react_jsx_runtime.JSX.Element;
type AgentWorkbenchShellLayout = "compact" | "drawer" | "mobile" | "wide";
type AgentWorkbenchShellMeasurement = "container" | "viewport";
interface AgentWorkbenchShellBreakpoints {
    mobile: number;
    drawer: number;
    compact: number;
    lowHeight: number;
}
declare const AGENT_WORKBENCH_SHELL_BREAKPOINTS: AgentWorkbenchShellBreakpoints;
declare function resolveAgentWorkbenchShellLayout(width: number, breakpoints?: AgentWorkbenchShellBreakpoints): AgentWorkbenchShellLayout;
interface AgentWorkbenchShellClassNames {
    root?: string;
    controls?: string;
    sidebar?: string;
    main?: string;
    details?: string;
    sidebarOverlay?: string;
    detailsOverlay?: string;
    resizeHandle?: string;
}
interface AgentWorkbenchShellLabels {
    openSidebar?: string;
    sidebar?: string;
    openDetails?: string;
    details?: string;
    resizeSidebar?: string;
    resizeDetails?: string;
}
interface AgentWorkbenchShellProps extends Omit<HTMLAttributes<HTMLDivElement>, "children">, AgentWorkbenchAppearanceOptions {
    /** Left navigation content. The shell only owns its layout and overflow boundary. */
    sidebar?: ReactNode;
    /** Primary conversation content. */
    children: ReactNode;
    /** Optional right-side task details or artifact workspace. */
    details?: ReactNode;
    /** Whether the left navigation is available to the layout. */
    sidebarOpen?: boolean;
    /** Whether the left navigation starts expanded in inline layouts. */
    sidebarDefaultOpen?: boolean;
    /** Whether the right details region is available to the layout. */
    detailsOpen?: boolean;
    /** Notified when a responsive details overlay closes. */
    onDetailsOpenChange?: (open: boolean) => void;
    /** Width of the left navigation column in CSS pixels or any valid CSS size. */
    sidebarWidth?: number | string;
    /** Width of the right details column in CSS pixels or any valid CSS size. */
    detailsWidth?: number | string;
    sidebarMinWidth?: number;
    sidebarMaxWidth?: number;
    detailsMinWidth?: number;
    detailsMaxWidth?: number;
    mainMinWidth?: number;
    /** Enables the canonical wide/compact/drawer/mobile layout policy. */
    responsive?: boolean;
    /** Container measurement is reusable; viewport keeps nested workbench shells in sync. */
    responsiveMeasurement?: AgentWorkbenchShellMeasurement;
    /** Explicit dimensions are useful for deterministic embeds and visual tests. */
    responsiveWidth?: number;
    responsiveHeight?: number;
    breakpoints?: AgentWorkbenchShellBreakpoints;
    onLayoutChange?: (layout: AgentWorkbenchShellLayout) => void;
    /** Shows the canonical navigation button whenever the sidebar becomes an overlay. */
    showResponsiveControls?: boolean;
    /** Shells with the same group id keep responsive overlays mutually exclusive. */
    overlayGroupId?: string;
    /** Enables pointer and keyboard resizing for inline side regions. */
    resizable?: boolean;
    widthStorageKey?: string;
    onSidebarWidthChange?: (width: number) => void;
    onDetailsWidthChange?: (width: number) => void;
    labels?: AgentWorkbenchShellLabels;
    classNames?: AgentWorkbenchShellClassNames;
}
/**
 * Canonical responsive shell for Agent workbenches.
 *
 * - >=1440px: complete three-column layout.
 * - 1200-1439px: compact navigation + main; details use an overlay.
 * - 768-1199px: main-only layout with mutually exclusive drawers.
 * - <768px: main-only layout with full-screen side panels.
 *
 * Every region remains bounded by one scroll owner. Opening or closing an
 * overlay never reparents the main conversation, so its scroll and runtime
 * state remain intact.
 */
declare function AgentWorkbenchShell({ sidebar, children, details, sidebarOpen, sidebarDefaultOpen, detailsOpen, onDetailsOpenChange, sidebarWidth, detailsWidth, sidebarMinWidth, sidebarMaxWidth, detailsMinWidth, detailsMaxWidth, mainMinWidth, responsive, responsiveMeasurement, responsiveWidth, responsiveHeight, breakpoints, onLayoutChange, showResponsiveControls, overlayGroupId, resizable, widthStorageKey, onSidebarWidthChange, onDetailsWidthChange, labels, variant, density, className, classNames, style, ...rootProps }: AgentWorkbenchShellProps): react_jsx_runtime.JSX.Element;
interface AgentWorkbenchTerminalModel {
    terminalId: string;
    stdin: string;
    stdout: string;
    stderr: string;
    status: string;
    exitCode?: number;
    sequence: number;
}
interface AgentWorkbenchDetailsModel {
    mode: AgentSessionViewModel['snapshot']['mode'];
    modelId: string;
    permissionProfile?: AgentSessionViewModel['snapshot']['permissionProfile'];
    status: AgentSessionViewModel['status'];
    sessionId: string;
    capabilities: AgentSessionCapabilities;
    resumable: boolean;
    summary?: AgentWorkbenchEventOf<'summary'>;
    error?: AgentWorkbenchEventOf<'error'>;
    run?: AgentWorkbenchEventOf<'status'>;
    usage?: AgentWorkbenchEventOf<'usage'>;
    workspace: {
        diffs: AgentWorkbenchEventOf<'diff'>[];
        files: AgentWorkbenchEventOf<'workspace-file'>[];
        terminals: AgentWorkbenchTerminalModel[];
        tests: AgentWorkbenchEventOf<'test-result'>[];
        artifacts: AgentWorkbenchEventOf<'artifact'>[];
    };
}
declare function createAgentWorkbenchDetailsModel(viewModel: AgentSessionViewModel): AgentWorkbenchDetailsModel;
export { type AgentWorkbenchDensity as $, AGENT_WORKBENCH_SHELL_BREAKPOINTS as A, type AgentWorkbenchShellProps as B, AgentWorkbenchSidebar as C, type AgentWorkbenchSidebarClassNames as D, AgentWorkbenchSidebarContainer as E, type AgentWorkbenchSidebarContainerBodyProps as F, type AgentWorkbenchSidebarContainerClassNames as G, type AgentWorkbenchSidebarContainerProps as H, type AgentWorkbenchSidebarIntent as I, type AgentWorkbenchSidebarProps as J, AgentWorkbenchTaskDetails as K, type AgentWorkbenchTaskDetailsClassNames as L, type AgentWorkbenchTaskDetailsProps as M, type AgentWorkbenchTerminalModel as N, AgentWorkbenchTool as O, type AgentWorkbenchToolClassNames as P, type AgentWorkbenchToolProps as Q, createAgentWorkbenchActivityModel as R, createAgentWorkbenchDetailsModel as S, resolveAgentWorkbenchShellLayout as T, type AgentWorkbenchAppearanceOptions as U, type AgentWorkbenchAppearance as V, AgentWorkbenchAppearanceProvider as W, type AgentWorkbenchAppearanceProviderProps as X, AgentWorkbenchApproval as Y, type AgentWorkbenchApprovalData as Z, type AgentWorkbenchApprovalProps as _, AgentWorkbenchActivity as a, AgentWorkbenchExploreCardMedia as a0, type AgentWorkbenchExploreCardMediaProps as a1, type AgentWorkbenchExploreMediaTreatment as a2, type AgentWorkbenchExploreMediaVariant as a3, AgentWorkbenchSurface as a4, type AgentWorkbenchSurfaceLevel as a5, type AgentWorkbenchSurfaceProps as a6, type AgentWorkbenchVariant as a7, resolveAgentWorkbenchAppearance as a8, type AgentWorkbenchActivityClassNames as b, type AgentWorkbenchActivityModel as c, type AgentWorkbenchActivityProps as d, type AgentWorkbenchApprovalIntent as e, type AgentWorkbenchArtifactIntent as f, type AgentWorkbenchDetailsIntent as g, type AgentWorkbenchDetailsModel as h, type AgentWorkbenchDetailsState as i, type AgentWorkbenchDetailsTab as j, type AgentWorkbenchEventOf as k, type AgentWorkbenchExploreGroup as l, type AgentWorkbenchExploreItem as m, AgentWorkbenchExploreSidebar as n, type AgentWorkbenchExploreSidebarIntent as o, type AgentWorkbenchExploreSidebarLabels as p, type AgentWorkbenchExploreSidebarProps as q, AgentWorkbenchQuickStart as r, type AgentWorkbenchQuickStartIntent as s, type AgentWorkbenchQuickStartProps as t, AgentWorkbenchShell as u, type AgentWorkbenchShellBreakpoints as v, type AgentWorkbenchShellClassNames as w, type AgentWorkbenchShellLabels as x, type AgentWorkbenchShellLayout as y, type AgentWorkbenchShellMeasurement as z };