@elevasis/ui 1.0.0

package/dist/components/index.d.ts

@@ -0,0 +1,1354 @@
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as react from 'react';
+import react__default, { ReactElement, ReactNode, ComponentType, CSSProperties } from 'react';
+import { MantineSpacing, MantineColor } from '@mantine/core';
+import { Icon, IconCheck } from '@tabler/icons-react';
+import { Components } from 'react-markdown';
+import { UseFormReturnType } from '@mantine/form';
+import { Node, Edge, NodeProps, EdgeProps } from '@xyflow/react';
+
+interface ICustomModalProps {
+    opened: boolean;
+    onClose: () => void;
+    children: react__default.ReactNode | react__default.ReactNode[] | string;
+    loading?: boolean;
+    style?: react__default.CSSProperties;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+}
+declare const CustomModal: ({ children, opened, onClose, loading, style, size }: ICustomModalProps) => react_jsx_runtime.JSX.Element;
+
+interface IConfirmationModalProps {
+    opened: boolean;
+    onClose: () => void;
+    icon: ReactElement<{
+        size?: number;
+        strokeWidth?: number;
+    }>;
+    confirmationHandler?: () => void;
+    loading?: boolean;
+    style?: React.CSSProperties;
+    title: string;
+    text?: ReactNode | string;
+    buttonText?: string;
+    buttonColor?: string;
+    centerText?: boolean;
+}
+declare const ConfirmationModal: ({ opened, onClose, loading, icon, confirmationHandler, style, title, text, buttonText, buttonColor, centerText }: IConfirmationModalProps) => react_jsx_runtime.JSX.Element;
+
+interface IConfirmationInputModalProps {
+    opened: boolean;
+    onClose: () => void;
+    icon: ReactElement<{
+        size?: number;
+        strokeWidth?: number;
+    }>;
+    confirmationHandler?: () => void;
+    loading?: boolean;
+    style?: React.CSSProperties;
+    title: string | ReactNode;
+    text?: ReactNode | string;
+    buttonText?: string;
+    buttonColor?: string;
+    centerText?: boolean;
+    inputValue: string;
+    onInputChange: (value: string) => void;
+    expectedValue: string;
+    placeholder?: string;
+}
+declare const ConfirmationInputModal: ({ opened, onClose, loading, icon, confirmationHandler, style, title, text, buttonText, buttonColor, inputValue, onInputChange, expectedValue, placeholder }: IConfirmationInputModalProps) => react_jsx_runtime.JSX.Element;
+
+interface APIErrorAlertProps {
+    /**
+     * The error to display. Can be an APIClientError, generic Error, or any unknown value.
+     */
+    error: unknown;
+    /**
+     * Optional title override. If not provided, uses getErrorTitle() based on error code.
+     */
+    title?: string;
+    /**
+     * Whether to show the request ID (if available). Defaults to true.
+     */
+    showRequestId?: boolean;
+    /**
+     * Optional custom icon. Defaults to IconAlertCircle.
+     */
+    icon?: React.ReactNode;
+    /**
+     * Alert color. Defaults to 'red'.
+     */
+    color?: string;
+}
+/**
+ * Alert component for displaying API errors with type-safe error handling.
+ *
+ * Automatically extracts error message, code, and request ID from APIClientError
+ * or falls back to generic Error handling.
+ *
+ * @example
+ * ```tsx
+ * const { data, error } = useQuery(...)
+ *
+ * if (error) {
+ *   return <APIErrorAlert error={error} />
+ * }
+ * ```
+ *
+ * @example With custom title
+ * ```tsx
+ * <APIErrorAlert
+ *   error={error}
+ *   title="Failed to load resources"
+ * />
+ * ```
+ *
+ * @example Without request ID
+ * ```tsx
+ * <APIErrorAlert
+ *   error={error}
+ *   showRequestId={false}
+ * />
+ * ```
+ */
+declare function APIErrorAlert({ error, title, showRequestId, icon, color }: APIErrorAlertProps): react_jsx_runtime.JSX.Element;
+
+interface CollapsibleSectionProps {
+    title: string | ReactNode;
+    count?: number;
+    countLabel?: string;
+    children: ReactNode;
+    emptyMessage?: string;
+    defaultExpanded?: boolean;
+    maxHeight?: number;
+}
+/**
+ * Reusable collapsible section with header, badge, and scroll area
+ * Used for expandable content like memory sections, logs, etc.
+ */
+declare function CollapsibleSection({ title, count, countLabel, children, emptyMessage, defaultExpanded, maxHeight }: CollapsibleSectionProps): react_jsx_runtime.JSX.Element;
+
+interface EmptyStateProps {
+    /** Icon component to display (e.g., IconKey from @tabler/icons-react) */
+    icon: ComponentType<{
+        size: number;
+        style?: React.CSSProperties;
+    }>;
+    /** Main title text */
+    title: string;
+    /** Description text shown below title */
+    description?: string;
+    /** Optional action button */
+    action?: {
+        label: string;
+        onClick: () => void;
+        icon?: ReactNode;
+    };
+    /** Vertical padding - defaults to 'xl' */
+    py?: MantineSpacing;
+}
+/**
+ * EmptyState - Reusable empty state component for lists and tables
+ *
+ * Consolidates the Center + Stack + Icon + Text pattern used across:
+ * - ApiKeyList.tsx
+ * - CredentialList.tsx
+ * - Various other list components
+ *
+ * @example
+ * ```tsx
+ * <EmptyState
+ *   icon={IconKey}
+ *   title="No API keys yet"
+ *   description="Create your first API key to enable external integrations"
+ *   action={{ label: "Create API Key", onClick: handleCreate }}
+ * />
+ * ```
+ */
+declare function EmptyState({ icon: Icon, title, description, action, py }: EmptyStateProps): react_jsx_runtime.JSX.Element;
+
+interface NavigationButtonProps {
+    /** Icon component to display */
+    icon: react__default.ComponentType<{
+        size?: number;
+        stroke?: number;
+    }>;
+    /** Button label text */
+    label: string;
+    /** Whether the button is in collapsed state (hides text) */
+    isCollapsed?: boolean;
+    /** Whether this button has sub-items/links */
+    hasSubItems?: boolean;
+    /** Whether sub-items are expanded (controls chevron rotation) */
+    isExpanded?: boolean;
+    /** Whether the icon and text should be styled as active */
+    isActive?: boolean;
+    /** Whether the background should be styled as active */
+    hasActiveBackground?: boolean;
+    /** Click handler */
+    onClick?: () => void;
+    /** Additional styles for the button container */
+    style?: react__default.CSSProperties;
+    /** Custom transition duration in ms */
+    transitionDuration?: number;
+}
+declare const NavigationButton: react__default.FC<NavigationButtonProps>;
+
+declare function PageNotFound(): react_jsx_runtime.JSX.Element;
+
+interface PageTitleCaptionProps {
+    title: string;
+    caption?: string;
+    rightSection?: ReactNode;
+}
+declare const PageTitleCaption: ({ title, caption, rightSection }: PageTitleCaptionProps) => react_jsx_runtime.JSX.Element;
+
+interface StatsCardSkeletonProps {
+    /** Height of the chart skeleton - defaults to 120 */
+    chartHeight?: number;
+    /** Whether to show a chart skeleton - defaults to true */
+    withChart?: boolean;
+    /** Number of stat columns - defaults to 3 */
+    statCount?: 2 | 3;
+}
+/**
+ * StatsCardSkeleton - Loading skeleton for dashboard metric cards
+ *
+ * Consolidates the identical card skeleton pattern used across:
+ * - ExecutionHealthCard.tsx
+ * - CostMetricsCard.tsx
+ * - ThroughputCard.tsx
+ * - BusinessImpactCard.tsx
+ *
+ * @example
+ * ```tsx
+ * if (isLoading) {
+ *   return <StatsCardSkeleton />
+ * }
+ * ```
+ */
+declare function StatsCardSkeleton({ chartHeight, withChart, statCount }: StatsCardSkeletonProps): react_jsx_runtime.JSX.Element;
+interface ListSkeletonProps {
+    /** Number of skeleton rows to show - defaults to 3 */
+    rows?: number;
+    /** Height of each row - defaults to 50 */
+    rowHeight?: number;
+}
+/**
+ * ListSkeleton - Loading skeleton for table/list content
+ *
+ * Consolidates the Stack + Skeleton pattern used across:
+ * - ApiKeyList.tsx
+ * - CredentialList.tsx
+ * - Various other list components
+ *
+ * @example
+ * ```tsx
+ * if (isLoading) {
+ *   return <ListSkeleton rows={5} />
+ * }
+ * ```
+ */
+declare function ListSkeleton({ rows, rowHeight }: ListSkeletonProps): react_jsx_runtime.JSX.Element;
+interface DetailCardSkeletonProps {
+    /** Number of detail rows - defaults to 3 */
+    rows?: number;
+}
+/**
+ * DetailCardSkeleton - Loading skeleton for cards with list of detail items
+ *
+ * Used for cards like CostBreakdownCard that show a list of items
+ *
+ * @example
+ * ```tsx
+ * if (isLoading) {
+ *   return <DetailCardSkeleton rows={4} />
+ * }
+ * ```
+ */
+declare function DetailCardSkeleton({ rows }: DetailCardSkeletonProps): react_jsx_runtime.JSX.Element;
+
+interface StatCardBaseProps {
+    /** The label/description text */
+    label: string;
+    /** The value to display (number or formatted string) */
+    value: string | number;
+    /** Tabler icon component */
+    icon: Icon;
+    /** Optional extra content rendered below the label */
+    children?: ReactNode;
+}
+interface StatCardDefaultProps extends StatCardBaseProps {
+    variant?: 'default';
+    /** Theme color for the icon (defaults to theme primary) */
+    color?: MantineColor;
+    isLoading?: never;
+    valueColor?: never;
+}
+interface StatCardHeroProps extends StatCardBaseProps {
+    variant: 'hero';
+    /** Whether data is loading */
+    isLoading?: boolean;
+    /** Custom color for the value text */
+    valueColor?: string;
+    /** Card sizing — 'sm' (default) for compact layouts, 'md' for spacious layouts */
+    size?: 'sm' | 'md';
+    color?: never;
+}
+type StatCardProps = StatCardDefaultProps | StatCardHeroProps;
+/**
+ * StatCard - Stat display card with icon, label, and value.
+ *
+ * Supports two variants:
+ * - `default`: Compact card with ThemeIcon (used in admin overviews)
+ * - `hero`: Glass card with glowing icon ring (used on dashboards)
+ *
+ * @example
+ * ```tsx
+ * // Default variant
+ * <StatCard label="Total Executions" value={150} icon={IconPlayerPlay} color="blue" />
+ *
+ * // Hero variant
+ * <StatCard variant="hero" label="Executions" value={43} icon={IconPlayerPlay} isLoading={false} />
+ * ```
+ */
+declare function StatCard(props: StatCardProps): react_jsx_runtime.JSX.Element;
+/**
+ * StatCardSkeleton - Loading skeleton for StatCard (default variant)
+ */
+declare function StatCardSkeleton(): react_jsx_runtime.JSX.Element;
+
+interface TabCountBadgeProps {
+    count: number;
+    isLoading?: boolean;
+}
+/**
+ * A badge that displays a count in tabs with consistent sizing.
+ * Uses a fixed-width container to prevent layout shift when switching
+ * between the loading spinner and the count badge.
+ */
+declare function TabCountBadge({ count, isLoading }: TabCountBadgeProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Shared form field types for dynamic form generation
+ * Used by: Command Queue, Execution Runner UI, future form-based features
+ */
+/**
+ * Supported form field types for action payloads
+ * Maps to Mantine form components
+ */
+type FormFieldType = 'text' | 'textarea' | 'number' | 'select' | 'checkbox' | 'radio' | 'richtext';
+/**
+ * Form field definition
+ */
+interface FormField {
+    /** Field key in payload object */
+    name: string;
+    /** Field label for UI */
+    label: string;
+    /** Field type (determines UI component) */
+    type: FormFieldType;
+    /** Default value */
+    defaultValue?: unknown;
+    /** Required field */
+    required?: boolean;
+    /** Placeholder text */
+    placeholder?: string;
+    /** Help text */
+    description?: string;
+    /** Options for select/radio */
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    /** Min/max for number */
+    min?: number;
+    max?: number;
+    /** Path to context value for pre-filling (dot notation, e.g., 'proposal.summary') */
+    defaultValueFromContext?: string;
+}
+/**
+ * Form schema for action payload collection
+ */
+interface FormSchema {
+    /** Form title */
+    title?: string;
+    /** Form description */
+    description?: string;
+    /** Form fields */
+    fields: FormField[];
+}
+
+/**
+ * Serialized Registry Types
+ *
+ * Pre-computed JSON-safe types for API responses and Command View.
+ * Serialization happens once at API startup, enabling instant response times.
+ */
+
+/**
+ * Serialized form field for API responses
+ */
+interface SerializedFormField {
+    name: string;
+    label: string;
+    type: FormFieldType;
+    defaultValue?: unknown;
+    required?: boolean;
+    placeholder?: string;
+    description?: string;
+    options?: Array<{
+        label: string;
+        value: string | number;
+    }>;
+    min?: number;
+    max?: number;
+}
+/**
+ * Serialized form schema for API responses
+ */
+interface SerializedFormSchema {
+    title?: string;
+    description?: string;
+    fields: SerializedFormField[];
+    layout?: 'vertical' | 'horizontal' | 'grid';
+}
+/**
+ * Serialized execution form schema for API responses
+ */
+interface SerializedExecutionFormSchema extends SerializedFormSchema {
+    fieldMappings?: Record<string, string>;
+    submitButton?: {
+        label?: string;
+        loadingLabel?: string;
+        confirmMessage?: string;
+    };
+}
+/**
+ * Serialized schedule config for API responses
+ */
+interface SerializedScheduleConfig {
+    enabled: boolean;
+    defaultSchedule?: string;
+    allowedPatterns?: string[];
+}
+/**
+ * Serialized webhook config for API responses
+ */
+interface SerializedWebhookConfig {
+    enabled: boolean;
+    payloadSchema?: unknown;
+}
+/**
+ * Serialized execution interface for API responses
+ */
+interface SerializedExecutionInterface {
+    form: SerializedExecutionFormSchema;
+    schedule?: SerializedScheduleConfig;
+    webhook?: SerializedWebhookConfig;
+}
+/**
+ * Serialized agent definition (JSON-safe)
+ * Result of serializeDefinition(AgentDefinition)
+ */
+interface SerializedAgentDefinition {
+    config: {
+        resourceId: string;
+        name: string;
+        description: string;
+        version: string;
+        type: 'agent';
+        status: 'dev' | 'prod';
+        /** Whether this resource is archived and should be excluded from registration and deployment */
+        archived?: boolean;
+        systemPrompt: string;
+        constraints?: {
+            maxIterations?: number;
+            timeout?: number;
+            maxSessionMemoryKeys?: number;
+            maxMemoryTokens?: number;
+        };
+        sessionCapable?: boolean;
+        memoryPreferences?: string;
+    };
+    modelConfig: {
+        provider: string;
+        model: string;
+        apiKey: string;
+        temperature: number;
+        maxOutputTokens: number;
+        topP?: number;
+        modelOptions?: Record<string, unknown>;
+    };
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    tools: Array<{
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+    }>;
+    knowledgeMap?: {
+        nodeCount: number;
+        nodes: Array<{
+            id: string;
+            description: string;
+            loaded: boolean;
+            hasPrompt: boolean;
+        }>;
+    };
+    metricsConfig?: object;
+    interface?: SerializedExecutionInterface;
+}
+/**
+ * Serialized workflow definition (JSON-safe)
+ * Result of serializeDefinition(WorkflowDefinition)
+ */
+interface SerializedWorkflowDefinition {
+    config: {
+        resourceId: string;
+        name: string;
+        description: string;
+        version: string;
+        type: 'workflow';
+        status: 'dev' | 'prod';
+        /** Whether this resource is archived and should be excluded from registration and deployment */
+        archived?: boolean;
+    };
+    entryPoint: string;
+    steps: Array<{
+        id: string;
+        name: string;
+        description: string;
+        inputSchema?: object;
+        outputSchema?: object;
+        next: {
+            type: 'linear' | 'conditional';
+            target?: string;
+            routes?: Array<{
+                target: string;
+            }>;
+            default?: string;
+        } | null;
+    }>;
+    contract: {
+        inputSchema: object;
+        outputSchema?: object;
+    };
+    metricsConfig?: object;
+    interface?: SerializedExecutionInterface;
+}
+
+/**
+ * Action configuration for HITL tasks
+ * Defines available user actions and their behavior
+ */
+interface ActionConfig {
+    /** Unique action identifier (e.g., 'approve', 'retry', 'escalate') */
+    id: string;
+    /** Display label for UI button */
+    label: string;
+    /** Button variant/style */
+    type: 'primary' | 'secondary' | 'danger' | 'outline';
+    /** Tabler icon name (e.g., 'IconCheck', 'IconRefresh') */
+    icon?: string;
+    /** Button color (Mantine theme colors) */
+    color?: string;
+    /** Button variant (Mantine button variant, e.g., 'light', 'filled', 'outline') */
+    variant?: string;
+    /** Execution target (agent/workflow to invoke) */
+    target?: {
+        resourceType: 'agent' | 'workflow';
+        resourceId: string;
+        /**
+         * Optional session ID for agent continuation.
+         * If provided, invokes a new turn on the existing session instead of standalone execution.
+         * Only valid when resourceType is 'agent'.
+         */
+        sessionId?: string;
+    };
+    /** Form schema for collecting action-specific data */
+    form?: FormSchema;
+    /** Payload template for pre-filling forms */
+    payloadTemplate?: unknown;
+    /** Requires confirmation dialog */
+    requiresConfirmation?: boolean;
+    /** Confirmation message */
+    confirmationMessage?: string;
+    /** Help text / tooltip */
+    description?: string;
+}
+
+/**
+ * Origin resource type - where an execution/task originated from.
+ * Used for audit trails and tracking execution lineage.
+ */
+type OriginResourceType = 'agent' | 'workflow' | 'scheduler' | 'api';
+/**
+ * Origin tracking metadata - who/what created this execution/task.
+ * Used by both TaskScheduler and CommandQueue for complete audit trails.
+ */
+interface OriginTracking {
+    originExecutionId: string;
+    originResourceType: OriginResourceType;
+    originResourceId: string;
+}
+
+/**
+ * Command queue task with flexible action system
+ */
+interface Task extends OriginTracking {
+    id: string;
+    organizationId: string;
+    actions: ActionConfig[];
+    context: unknown;
+    selectedAction?: string;
+    actionPayload?: unknown;
+    description?: string;
+    priority: number;
+    /** Optional checkpoint identifier for grouping related human approval tasks */
+    humanCheckpoint?: string;
+    status: TaskStatus;
+    /**
+     * Target resource tracking — mirrors origin columns.
+     * Set when task is created; patchable to redirect execution to a different resource.
+     */
+    targetResourceId?: string;
+    targetResourceType?: 'agent' | 'workflow';
+    /**
+     * Execution ID for the action that runs AFTER user approval.
+     * NULL until execution starts.
+     *
+     * Naming distinction:
+     * - originExecutionId = Parent execution that CREATED the HITL task
+     * - targetExecutionId = Child execution that RUNS AFTER user approval
+     */
+    targetExecutionId?: string;
+    createdAt: Date;
+    completedAt?: Date;
+    completedBy?: string;
+    expiresAt?: Date;
+    idempotencyKey?: string | null;
+}
+/**
+ * Task status values
+ * - pending: awaiting action
+ * - processing: execution in progress after user approval
+ * - completed: action was taken and execution succeeded
+ * - failed: execution failed, task can be retried
+ * - expired: timed out before action
+ */
+type TaskStatus = 'pending' | 'processing' | 'completed' | 'failed' | 'expired';
+
+/**
+ * Wire-format DTO for notification API responses.
+ * Dates are ISO 8601 strings (not Date objects like the domain Notification type).
+ * Used by frontend hooks that consume /api/notifications.
+ */
+interface NotificationDTO {
+    id: string;
+    userId: string;
+    organizationId: string;
+    category: string;
+    title: string;
+    message: string;
+    actionUrl: string | null;
+    read: boolean;
+    readAt: string | null;
+    createdAt: string;
+}
+
+type MessageType = MessageEvent['type'];
+interface ChatMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    messageType: MessageType;
+    text: string;
+    metadata?: MessageEvent;
+    turnNumber: number;
+    messageIndex?: number;
+    createdAt: Date;
+}
+
+/**
+ * Time range selector for dashboard metrics
+ */
+type TimeRange = '1h' | '24h' | '7d' | '30d';
+/** Time-bucketed health data point */
+interface ResourceHealthDataPoint {
+    time: string;
+    success: number;
+    failure: number;
+    warning: number;
+    rate: number;
+}
+/** Health data for a single resource */
+interface ResourceHealth {
+    entityType: string;
+    entityId: string;
+    entityName: string | null;
+    trendData: ResourceHealthDataPoint[];
+    summary: {
+        total: number;
+        successRate: number;
+    };
+}
+
+/**
+ * Base Execution Engine type definitions
+ * Core types shared across all Execution Engine resources
+ */
+
+/**
+ * Unified message event type - covers all message types in sessions
+ * Replaces separate SessionTurnMessages and AgentActivityEvent mechanisms
+ */
+/**
+ * Structured action metadata attached to assistant messages.
+ * Frontend reads this instead of parsing text prefixes.
+ */
+type AssistantAction = {
+    kind: 'navigate';
+    path: string;
+    reason: string;
+} | {
+    kind: 'update_filters';
+    timeRange: string | null;
+    statusFilter: string | null;
+    searchQuery: string | null;
+};
+type MessageEvent = {
+    type: 'user_message';
+    text: string;
+} | {
+    type: 'assistant_message';
+    text: string;
+    _action?: AssistantAction;
+} | {
+    type: 'agent:started';
+} | {
+    type: 'agent:completed';
+} | {
+    type: 'agent:error';
+    error: string;
+} | {
+    type: 'agent:reasoning';
+    iteration: number;
+    reasoning: string;
+} | {
+    type: 'agent:tool_call';
+    toolName: string;
+    args: Record<string, unknown>;
+} | {
+    type: 'agent:tool_result';
+    toolName: string;
+    success: boolean;
+    result?: unknown;
+    error?: string;
+};
+/**
+ * NOTE: AIResource interface has been removed and replaced with ResourceDefinition
+ * from registry/types.ts. All resources (executable and non-executable) now extend
+ * the unified ResourceDefinition base interface.
+ *
+ * AgentConfig and WorkflowConfig now extend ResourceDefinition directly.
+ * See packages/core/src/registry/types.ts for the base interface definition.
+ */
+type AIResourceDefinition = SerializedWorkflowDefinition | SerializedAgentDefinition;
+
+/**
+ * Resource Registry type definitions
+ */
+
+/**
+ * Environment/deployment status for resources
+ */
+type ResourceStatus = 'dev' | 'prod';
+/**
+ * All resource types in the platform
+ * Used as the discriminator field in ResourceDefinition
+ */
+type ResourceType = 'agent' | 'workflow' | 'trigger' | 'integration' | 'external' | 'human';
+/**
+ * Base interface for ALL platform resources
+ * Shared by both executable (agents, workflows) and non-executable (triggers, integrations, etc.) resources
+ */
+interface ResourceDefinition {
+    /** Unique resource identifier */
+    resourceId: string;
+    /** Display name */
+    name: string;
+    /** Purpose and functionality description */
+    description: string;
+    /** Version for change tracking and evolution */
+    version: string;
+    /** Resource type discriminator */
+    type: ResourceType;
+    /** Environment/deployment status */
+    status: ResourceStatus;
+    /** Domain tags for filtering and organization */
+    domains?: ResourceDomain[];
+    /** Whether the agent supports multi-turn sessions (agents only) */
+    sessionCapable?: boolean;
+    /** Whether the resource is local (monorepo) or remote (externally deployed) */
+    origin?: 'local' | 'remote';
+    /** Whether this resource is archived and should be excluded from registration and deployment */
+    archived?: boolean;
+}
+
+/**
+ * Standard Domain Definitions
+ * Centralized domain constants and definitions for all organization resources.
+ */
+
+declare const DOMAINS: {
+    readonly INBOUND_PIPELINE: "inbound-pipeline";
+    readonly LEAD_GEN_PIPELINE: "lead-gen-pipeline";
+    readonly SUPPORT: "support";
+    readonly CLIENT_SUPPORT: "client-support";
+    readonly DELIVERY: "delivery";
+    readonly OPERATIONS: "operations";
+    readonly FINANCE: "finance";
+    readonly EXECUTIVE: "executive";
+    readonly INSTANTLY: "instantly";
+    readonly TESTING: "testing";
+    readonly INTERNAL: "internal";
+    readonly INTEGRATION: "integration";
+    readonly UTILITY: "utility";
+    readonly DIAGNOSTIC: "diagnostic";
+};
+/**
+ * ResourceDomain - Strongly typed domain identifier
+ * Use this type for all domain references to ensure compile-time validation.
+ */
+type ResourceDomain = (typeof DOMAINS)[keyof typeof DOMAINS];
+
+type ExecutionStatus = 'pending' | 'running' | 'completed' | 'failed' | 'warning';
+
+/**
+ * Execution Runner Types
+ *
+ * Shared types for the Execution Runner UI feature.
+ * Used by both API (apps/api) and frontend (apps/command-center).
+ */
+
+interface ExecutionRunnerCatalogItem {
+    resourceId: string;
+    resourceName: string;
+    resourceType: 'workflow' | 'agent';
+    description?: string;
+    status: 'dev' | 'prod';
+    version: string;
+    interface: SerializedExecutionInterface;
+}
+
+interface TimeRangeSelectorProps {
+    value: TimeRange;
+    onChange: (value: TimeRange) => void;
+    width?: number;
+}
+declare function TimeRangeSelector({ value, onChange, width }: TimeRangeSelectorProps): react_jsx_runtime.JSX.Element;
+
+interface CustomSelectorProps {
+    value: string | null;
+    onChange: (value: string | null) => void;
+    data: {
+        value: string;
+        label: string;
+    }[] | readonly {
+        value: string;
+        label: string;
+    }[];
+    leftSection?: ReactNode;
+    placeholder?: string;
+    w?: number | string;
+    withCheckIcon?: boolean;
+    disabled?: boolean;
+}
+declare function CustomSelector({ value, onChange, data, leftSection, placeholder, w, withCheckIcon, disabled }: CustomSelectorProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * TrendIndicator - Reusable component for showing percentage change trends
+ * Displays up/down/flat arrow with colored badge
+ */
+interface TrendIndicatorProps {
+    /** Current value */
+    current: number;
+    /** Previous value to compare against */
+    previous: number;
+    /** Optional formatter for the value (not used in display but kept for API compatibility) */
+    formatter?: (value: number) => string;
+    /** If true, negative change is considered positive (e.g., for costs) */
+    inverse?: boolean;
+}
+/**
+ * Shows a trend indicator with arrow icon and percentage change badge
+ *
+ * @example
+ * // Positive trend (green when going up)
+ * <TrendIndicator current={100} previous={80} />
+ *
+ * @example
+ * // Inverse trend (green when going down, useful for costs)
+ * <TrendIndicator current={100} previous={120} inverse />
+ */
+declare function TrendIndicator({ current, previous, inverse }: TrendIndicatorProps): react_jsx_runtime.JSX.Element;
+
+interface ContextViewerProps {
+    /** Any JSON-serializable data to display in a human-readable format */
+    data: unknown;
+}
+/**
+ * Auto-formats any JSON context into a human-readable layout.
+ *
+ * - Strings → rendered as markdown (supports formatting, lists, tables)
+ * - Flat key-value objects → labeled field list
+ * - Nested objects → indented subsections with left border
+ * - Arrays → bulleted lists or bordered cards
+ * - null/undefined/boolean/number → inline text
+ *
+ * No display configuration needed — the component infers layout from data shape.
+ */
+declare function ContextViewer({ data }: ContextViewerProps): react_jsx_runtime.JSX.Element;
+
+interface JsonViewerProps {
+    /** JSON data to display (will be stringified) or pre-formatted JSON string */
+    data: unknown;
+    /** Maximum height with scroll (e.g., '300px'). If not set, expands to content */
+    maxHeight?: string | number;
+    /** Font size override */
+    fontSize?: string | number;
+}
+/**
+ * Syntax-highlighted JSON viewer component
+ *
+ * @example
+ * ```tsx
+ * import { JsonViewer } from '@repo/ui'
+ *
+ * <JsonViewer data={{ foo: 'bar', count: 42 }} />
+ * <JsonViewer data={apiResponse} maxHeight={300} />
+ * ```
+ */
+declare function JsonViewer({ data, maxHeight, fontSize }: JsonViewerProps): react_jsx_runtime.JSX.Element;
+
+interface StyledMarkdownProps {
+    /** Markdown content to render */
+    children: string;
+    /** Custom component overrides */
+    components?: Partial<Components>;
+    /** Additional class name */
+    className?: string;
+    /** Inline styles for the wrapper div */
+    style?: React.CSSProperties;
+}
+/**
+ * Styled markdown renderer with Mantine components and syntax highlighting
+ *
+ * Features:
+ * - Colored headings using theme primary color
+ * - Syntax-highlighted code blocks (oneDark theme, no token backgrounds)
+ * - Styled inline code with Mantine Code component
+ * - Styled blockquotes with left border
+ * - Proper list styling
+ *
+ * @example
+ * ```tsx
+ * import { StyledMarkdown } from '@repo/ui'
+ *
+ * <StyledMarkdown>{markdownContent}</StyledMarkdown>
+ * ```
+ */
+declare function StyledMarkdown({ children, components, className, style }: StyledMarkdownProps): react_jsx_runtime.JSX.Element;
+
+interface ResourceCardProps {
+    resource: ResourceDefinition;
+    onClick: (resource: ResourceDefinition) => void;
+    /** Layout mode: 'stack' renders vertically (default), 'row' renders as a dense horizontal strip, 'grid' renders with a right section, 'card' renders with top section above details */
+    layout?: 'stack' | 'row' | 'grid' | 'card';
+    /** Content rendered in the right column when layout is 'grid' */
+    rightSection?: ReactNode;
+    /** Content rendered above the details when layout is 'card' */
+    topSection?: ReactNode;
+    /** Optional "Last run X ago" label shown below status badges */
+    lastRunLabel?: string;
+    /** HTML data attributes and style overrides passed to the root Card */
+    'data-resource-id'?: string;
+    style?: CSSProperties;
+}
+declare function ResourceCard({ resource, onClick, layout, rightSection, topSection, lastRunLabel, style, ...rest }: ResourceCardProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Converts ExecutionRunnerCatalogItem to ResourceDefinition format
+ * for use with the unified ResourceCard component.
+ *
+ * @param item - ExecutionRunnerCatalogItem from the execution runner API
+ * @returns ResourceDefinition compatible with ResourceCard
+ *
+ * @example
+ * const catalogItem = {
+ *   resourceId: 'wf-001',
+ *   resourceName: 'Order Processor',
+ *   resourceType: 'workflow',
+ *   description: 'Processes customer orders',
+ *   status: 'prod',
+ *   version: '1.0.0',
+ *   interface: { ... }
+ * }
+ *
+ * const resource = catalogItemToResourceDefinition(catalogItem)
+ * <ResourceCard resource={resource} />
+ */
+declare function catalogItemToResourceDefinition(item: ExecutionRunnerCatalogItem): ResourceDefinition;
+
+interface MessageBubbleProps {
+    message: ChatMessage;
+}
+/**
+ * Shared chat message bubble component
+ * Used across all chat interfaces in the monorepo
+ * Supports all 8 message types including agent activity
+ */
+declare const MessageBubble: react.NamedExoticComponent<MessageBubbleProps>;
+
+interface ChatInterfaceProps {
+    messages: ChatMessage[];
+    input: string;
+    onInputChange: (value: string) => void;
+    onSendMessage: () => void;
+    isProcessing?: boolean;
+    isConnected?: boolean;
+    error?: string | null;
+    onClearError?: () => void;
+    emptyStateText?: string;
+    emptyStateSubtext?: string;
+    placeholder?: string;
+}
+/**
+ * Shared chat interface component
+ * Used across ai studio sessions and production agent chat
+ * Handles message display, auto-scroll, and input area
+ */
+declare function ChatInterface({ messages, input, onInputChange, onSendMessage, isProcessing, isConnected, error, onClearError, emptyStateText, emptyStateSubtext, placeholder }: ChatInterfaceProps): react_jsx_runtime.JSX.Element;
+
+interface ChatInputAreaProps {
+    input: string;
+    onInputChange: (value: string) => void;
+    onSend: () => void;
+    isDisabled?: boolean;
+    isProcessing?: boolean;
+    isConnected?: boolean;
+    placeholder?: string;
+}
+/**
+ * Tactical chat input area with focus glow and accent send button.
+ */
+declare const ChatInputArea: react.NamedExoticComponent<ChatInputAreaProps>;
+
+interface ChatHeaderProps {
+    title: string;
+    status?: {
+        label: string;
+        color: 'green' | 'gray' | 'red' | 'yellow' | 'blue';
+    };
+    contextUsage?: {
+        used: number;
+        total: number;
+    };
+    sidebarIcon?: ReactNode;
+    onToggleSidebar?: () => void;
+    isSidebarOpen?: boolean;
+    sidebarTooltip?: string;
+}
+/**
+ * Shared chat header component
+ * Displays title, status badge, context usage, and optional sidebar toggle
+ */
+declare function ChatHeader({ title, status, contextUsage, sidebarIcon, onToggleSidebar, isSidebarOpen, sidebarTooltip }: ChatHeaderProps): react_jsx_runtime.JSX.Element;
+
+interface ChatSidebarProps {
+    /**
+     * Whether the sidebar is open
+     */
+    isOpen: boolean;
+    /**
+     * Optional title for the sidebar header
+     * @default 'Details'
+     */
+    title?: string;
+    /**
+     * Sidebar content
+     */
+    children: ReactNode;
+    /**
+     * Optional fixed width in pixels
+     * @default 320
+     */
+    width?: number;
+    /**
+     * Optional z-index for layering
+     * @default 10
+     */
+    zIndex?: number;
+}
+/**
+ * Shared chat sidebar component
+ *
+ * Provides a sliding sidebar panel that animates from the right side.
+ * Used across AI Studio sessions and Agent Chat for displaying contextual details.
+ *
+ * Features:
+ * - Smooth transform-based sliding animation
+ * - Fixed width with absolute positioning
+ * - Theme-aware styling with CSS variables
+ * - Customizable header with optional actions
+ * - Flexible content area via children prop
+ *
+ * Layout Pattern:
+ * Parent container must have `position: relative` and the content area should
+ * adjust its `marginRight` to match the sidebar width when open.
+ *
+ * @example
+ * ```tsx
+ * <div style={{ position: 'relative', height: '100vh' }}>
+ *   <div style={{
+ *     marginRight: isSidebarOpen ? '320px' : '0',
+ *     transition: 'margin-right 0.3s cubic-bezier(0.4, 0, 0.2, 1)'
+ *   }}>
+ *     // Main content
+ *   </div>
+ *   <ChatSidebar isOpen={isSidebarOpen} onClose={() => setIsOpen(false)}>
+ *     // Sidebar content
+ *   </ChatSidebar>
+ * </div>
+ * ```
+ */
+declare function ChatSidebar({ isOpen, title, children, width, zIndex }: ChatSidebarProps): react_jsx_runtime.JSX.Element;
+
+interface ExecutionLogEntry {
+    id: string;
+    resourceId: string;
+    resourceName: string;
+    resourceType: 'workflow' | 'agent' | 'pipeline';
+    status: ExecutionStatus;
+    startTime: number;
+    endTime?: number;
+    duration?: number;
+    resourceStatus: 'dev' | 'prod';
+    resourceVersion?: string | null;
+    apiVersion?: string | null;
+    sdkVersion?: string | null;
+}
+interface ExecutionLogsTableProps {
+    executions: ExecutionLogEntry[];
+    isLoading: boolean;
+    onRowClick?: (params: {
+        resourceType: string;
+        resourceId: string;
+        executionId: string;
+    }) => void;
+}
+declare function ExecutionLogsTable({ executions, isLoading, onRowClick }: ExecutionLogsTableProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Get chart color based on success rate
+ */
+declare function getHealthColor(successRate: number, hasExecutions?: boolean): string;
+interface ResourceHealthChartProps {
+    healthData: ResourceHealth | undefined;
+    hasExecutions?: boolean;
+    width?: number | string;
+    height?: number;
+}
+/**
+ * Mini health chart for resource cards
+ */
+declare function ResourceHealthChart({ healthData, hasExecutions, width, height }: ResourceHealthChartProps): react_jsx_runtime.JSX.Element;
+
+interface FormFieldRendererProps {
+    field: FormField;
+    form: UseFormReturnType<any>;
+    richTextRenderer?: (props: {
+        content: string;
+        onChange: (content: string) => void;
+        placeholder?: string;
+    }) => ReactNode;
+}
+declare function FormFieldRenderer({ field, form, richTextRenderer }: FormFieldRendererProps): string | number | bigint | boolean | Iterable<ReactNode> | Promise<string | number | bigint | boolean | react.ReactPortal | react.ReactElement<unknown, string | react.JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | react_jsx_runtime.JSX.Element | null | undefined;
+
+interface TaskCardProps {
+    task: Task;
+    onViewExecution?: (params: {
+        resourceType: string;
+        resourceId: string;
+        executionId: string;
+    }) => void;
+    richTextRenderer?: (props: {
+        content: string;
+        onChange: (content: string) => void;
+        placeholder?: string;
+    }) => ReactNode;
+}
+declare function TaskCard({ task, onViewExecution, richTextRenderer }: TaskCardProps): react_jsx_runtime.JSX.Element;
+
+interface ActionModalProps {
+    action: ActionConfig;
+    task: Task;
+    opened: boolean;
+    onClose: () => void;
+    onSubmit: (payload: unknown, notes?: string) => void;
+    richTextRenderer?: (props: {
+        content: string;
+        onChange: (content: string) => void;
+        placeholder?: string;
+    }) => ReactNode;
+    error?: unknown;
+    isPending?: boolean;
+}
+declare function ActionModal({ action, task, opened, onClose, onSubmit, richTextRenderer, error, isPending }: ActionModalProps): react_jsx_runtime.JSX.Element | null;
+
+declare const iconMap: Record<string, typeof IconCheck>;
+/** Allowed icon names: IconCheck, IconX, IconRefresh, IconAlertTriangle, IconEdit, IconEye, IconRocket, IconMessageCircle, IconArrowUp, IconClock, IconFileText, IconSend, IconMail */
+declare function getIcon(iconName?: string): typeof IconCheck | null;
+
+interface NotificationItemProps {
+    notification: NotificationDTO;
+    onClose?: () => void;
+    onNavigate?: (url: string) => void;
+}
+declare function NotificationItem({ notification, onClose, onNavigate }: NotificationItemProps): react_jsx_runtime.JSX.Element;
+
+interface NotificationListProps {
+    notifications: NotificationDTO[];
+    isLoading?: boolean;
+    onClose?: () => void;
+    onNavigate?: (url: string) => void;
+}
+declare function NotificationList({ notifications, isLoading, onClose, onNavigate }: NotificationListProps): react_jsx_runtime.JSX.Element;
+
+interface NotificationPanelProps {
+    notifications: NotificationDTO[];
+    isLoading?: boolean;
+    onClose?: () => void;
+    onNavigate?: (url: string) => void;
+}
+declare function NotificationPanel({ notifications, isLoading, onClose, onNavigate }: NotificationPanelProps): react_jsx_runtime.JSX.Element;
+
+interface NotificationBellProps {
+    /** Override unread count (e.g., from SSE-enhanced source) */
+    unreadCount?: number;
+    /** Callback for navigation when notification is clicked */
+    onNavigate?: (url: string) => void;
+}
+declare function NotificationBell({ unreadCount, onNavigate }: NotificationBellProps): react_jsx_runtime.JSX.Element;
+
+interface ResourceDefinitionSectionProps {
+    resourceDefinition: AIResourceDefinition;
+    defaultExpanded?: boolean;
+}
+declare function ResourceDefinitionSection({ resourceDefinition, defaultExpanded }: ResourceDefinitionSectionProps): react_jsx_runtime.JSX.Element;
+
+interface AgentDefinitionDisplayProps {
+    agent: SerializedAgentDefinition;
+    defaultExpanded?: boolean;
+}
+declare function AgentDefinitionDisplay({ agent, defaultExpanded }: AgentDefinitionDisplayProps): react_jsx_runtime.JSX.Element;
+
+interface WorkflowDefinitionDisplayProps {
+    workflow: SerializedWorkflowDefinition;
+    defaultExpanded?: boolean;
+}
+declare function WorkflowDefinitionDisplay({ workflow, defaultExpanded }: WorkflowDefinitionDisplayProps): react_jsx_runtime.JSX.Element;
+
+interface ContractDisplayProps {
+    contract: {
+        inputSchema: unknown;
+        outputSchema?: unknown;
+    };
+    defaultExpanded?: boolean;
+}
+declare function ContractDisplay({ contract, defaultExpanded }: ContractDisplayProps): react_jsx_runtime.JSX.Element;
+
+interface ConfigItem {
+    label: string;
+    value: ReactNode;
+    mono?: boolean;
+}
+interface ConfigCardProps {
+    icon: ReactNode;
+    title: string;
+    badge?: string;
+    items: ConfigItem[];
+    color?: string;
+}
+declare function ConfigCard({ icon, title, badge, items, color }: ConfigCardProps): react_jsx_runtime.JSX.Element | null;
+
+interface ToolInfo {
+    name: string;
+    description?: string;
+}
+interface ToolsListDisplayProps {
+    tools: Array<string | ToolInfo>;
+    compact?: boolean;
+    maxVisible?: number;
+}
+declare function ToolsListDisplay({ tools, compact, maxVisible }: ToolsListDisplayProps): react_jsx_runtime.JSX.Element;
+
+interface CollapsibleJsonSectionProps {
+    title: React.ReactNode;
+    data: unknown;
+    defaultExpanded?: boolean;
+}
+declare function CollapsibleJsonSection({ title, data, defaultExpanded }: CollapsibleJsonSectionProps): react_jsx_runtime.JSX.Element;
+
+/**
+ * Shared types for ResourceDefinition components
+ */
+/** Serialized knowledge node from API response */
+interface SerializedKnowledgeNode {
+    id: string;
+    description: string;
+    loaded: boolean;
+    hasPrompt: boolean;
+    [key: string]: unknown;
+}
+/** Serialized knowledge map from API response */
+interface SerializedKnowledgeMap {
+    nodeCount: number;
+    nodes: SerializedKnowledgeNode[];
+}
+
+interface NewKnowledgeMapGraphProps {
+    knowledgeMap: SerializedKnowledgeMap;
+    agentName: string;
+    compact?: boolean;
+    fitViewTrigger?: number;
+}
+declare function NewKnowledgeMapGraph(props: NewKnowledgeMapGraphProps): react_jsx_runtime.JSX.Element;
+
+interface KnowledgeMapNodeData {
+    id: string;
+    name: string;
+    description: string;
+    loaded: boolean;
+    hasPrompt: boolean;
+    isAgentNode: boolean;
+    [key: string]: unknown;
+}
+interface KnowledgeMapEdgeData {
+    [key: string]: unknown;
+}
+declare function useNewKnowledgeMapLayout(knowledgeMap: SerializedKnowledgeMap | undefined, agentName: string): {
+    nodes: Node<KnowledgeMapNodeData>[];
+    edges: Edge<KnowledgeMapEdgeData>[];
+};
+
+type NewKnowledgeMapNodeProps = NodeProps<Node<KnowledgeMapNodeData>>;
+declare const NewKnowledgeMapNode: react.NamedExoticComponent<NewKnowledgeMapNodeProps>;
+
+type NewKnowledgeMapEdgeProps = EdgeProps<Edge<KnowledgeMapEdgeData, string>>;
+declare const NewKnowledgeMapEdge: react.NamedExoticComponent<NewKnowledgeMapEdgeProps>;
+
+export { APIErrorAlert, ActionModal, AgentDefinitionDisplay, ChatHeader, ChatInputArea, ChatInterface, ChatSidebar, CollapsibleJsonSection, CollapsibleSection, ConfigCard, ConfirmationInputModal, ConfirmationModal, ContextViewer, ContractDisplay, CustomModal, CustomSelector, DetailCardSkeleton, EmptyState, ExecutionLogsTable, FormFieldRenderer, JsonViewer, ListSkeleton, MessageBubble, NavigationButton, NewKnowledgeMapEdge, NewKnowledgeMapGraph, NewKnowledgeMapNode, NotificationBell, NotificationItem, NotificationList, NotificationPanel, PageNotFound, PageTitleCaption, ResourceCard, ResourceDefinitionSection, ResourceHealthChart, StatCard, StatCardSkeleton, StatsCardSkeleton, StyledMarkdown, TabCountBadge, TaskCard, TimeRangeSelector, ToolsListDisplay, TrendIndicator, WorkflowDefinitionDisplay, catalogItemToResourceDefinition, getHealthColor, getIcon, iconMap, useNewKnowledgeMapLayout };
+export type { ContextViewerProps, ExecutionLogEntry, ExecutionLogsTableProps, JsonViewerProps, KnowledgeMapEdgeData, KnowledgeMapNodeData, NavigationButtonProps, SerializedKnowledgeMap, SerializedKnowledgeNode, StatCardProps, StyledMarkdownProps, TrendIndicatorProps };