import { ReactNode, ComponentType } from 'react';
import { IconBrain } from '@tabler/icons-react';
import * as react_jsx_runtime from 'react/jsx-runtime';
import { z } from 'zod';
import { ButtonProps } from '@mantine/core';

type TablerIconComponent = typeof IconBrain;

type SystemSidebarComponent = ComponentType;
type SystemIconComponent = ComponentType<{
    size?: number;
    stroke?: number;
}>;
type SystemSidebarWidthResolver = number | ((context: {
    currentPath: string;
}) => number);
interface SystemModule {
    /** Unique stable identifier for this UI system module. */
    key: string;
    /** Organization Model system id this module presents. Omit for navigation-only app surfaces. */
    systemId?: string;
    /** Route prefixes owned by navigation-only app surfaces. */
    routePrefixes?: string[];
    /** Capability identifiers contributed by this system module. */
    capabilityIds?: string[];
    /** Icon used when this system node appears in shell navigation. */
    icon?: SystemIconComponent;
    /** Sidebar component rendered when this system's subtree route is active. */
    sidebar?: SystemSidebarComponent;
    /** Optional shell sidebar width override. Defaults to 250px. */
    sidebarWidth?: SystemSidebarWidthResolver;
    /** Operations-only bridge connecting this system to the organization graph node. */
    organizationGraph?: OrganizationGraphSystemBridge;
}
/**
 * A resolved topbar action — the OM node after gating/filtering, with icon resolved
 * from the semantic icon registry. Passed to `TopbarActionModule.render`.
 */
interface ResolvedTopbarAction {
    id: string;
    label: string;
    tooltip?: string;
    icon: TablerIconComponent;
    order: number;
}
/**
 * A topbar action module — binds a registry key to UI behavior (a render callback).
 * The key must match `navigation.topbar[id]`. The OM supplies data + visibility;
 * the module supplies behavior.
 */
interface TopbarActionModule {
    /** Stable key that matches the `id` of a `navigation.topbar` node. */
    key: string;
    /** Render the topbar action. Receives the resolved OM node (icon pre-resolved). */
    render: (ctx: {
        node: ResolvedTopbarAction;
    }) => ReactNode;
}
interface OrganizationGraphSystemBridge {
    systemId?: string;
}

declare const submittedRequestsManifest: SystemModule;

/**
 * Topbar action manifest for the `request` entry point.
 *
 * The registry key `'request'` matches `navigation.topbar.request` authored
 * in the Organization Model (Agent 3B). The OM node controls visibility and
 * order; this module supplies the behavior (renders RequestActionIcon which
 * owns its own icon, tooltip, and modal disclosure).
 */
declare const requestTopbarActionManifest: TopbarActionModule;

/**
 * Request Reporting API Schemas
 *
 * Request/response validation for /api/requests and /api/external/requests surfaces.
 * Used by both the API (routes.ts, external-routes.ts) and the CLI.
 *
 * Table mapping:
 *   reported_requests -> RequestSchemas
 */
declare const RequestSeverityEnum: z.ZodEnum<{
    warning: "warning";
    info: "info";
    critical: "critical";
}>;
declare const RequestStatusEnum: z.ZodEnum<{
    open: "open";
    resolved: "resolved";
    investigating: "investigating";
    wont_fix: "wont_fix";
}>;
declare const RequestSourceEnum: z.ZodEnum<{
    agent: "agent";
    api: "api";
    user: "user";
    external: "external";
    webhook: "webhook";
    cli: "cli";
}>;
declare const RequestTypeEnum: z.ZodEnum<{
    other: "other";
    feature: "feature";
    bug: "bug";
    question: "question";
}>;
type RequestSeverity = z.infer<typeof RequestSeverityEnum>;
type RequestStatus = z.infer<typeof RequestStatusEnum>;
type RequestSource = z.infer<typeof RequestSourceEnum>;
type RequestType$1 = z.infer<typeof RequestTypeEnum>;

interface RequestsListPageProps {
    type?: RequestType$1;
    severity?: RequestSeverity;
    status?: RequestStatus;
    source?: RequestSource;
    onNavigateToRequest?: (id: string) => void;
    /** Optional action placed in the page title row (e.g. a RequestButton trigger). */
    rightSection?: ReactNode;
}
declare function RequestsListPage({ type: typeProp, severity: severityProp, status: statusProp, source: sourceProp, onNavigateToRequest, rightSection }: RequestsListPageProps): react_jsx_runtime.JSX.Element;

interface RequestsDetailPageProps {
    requestId: string;
    onNavigateBack?: () => void;
}
declare function RequestsDetailPage({ requestId, onNavigateBack }: RequestsDetailPageProps): react_jsx_runtime.JSX.Element;

interface RequestTypeBadgeProps {
    type: RequestType$1;
}
declare function RequestTypeBadge({ type }: RequestTypeBadgeProps): react_jsx_runtime.JSX.Element;

interface SeverityBadgeProps {
    severity: RequestSeverity;
}
declare function SeverityBadge({ severity }: SeverityBadgeProps): react_jsx_runtime.JSX.Element;

interface StatusBadgeProps {
    status: RequestStatus;
}
declare function StatusBadge({ status }: StatusBadgeProps): react_jsx_runtime.JSX.Element;

interface StatusTransitionMenuProps {
    currentStatus: RequestStatus;
    onTransition: (newStatus: RequestStatus) => void;
}
/**
 * StatusTransitionMenu — Mantine Menu for triaging request status.
 *
 * Visually disables transitions that are not valid from the current status.
 * Selecting "Won't Fix" opens a confirmation modal before calling onTransition.
 * No mutation logic lives here — the parent wires useUpdateRequestStatus.
 */
declare function StatusTransitionMenu({ currentStatus, onTransition }: StatusTransitionMenuProps): react_jsx_runtime.JSX.Element;

type RequestType = 'feature' | 'bug' | 'question' | 'other';

interface RequestModalProps {
    opened: boolean;
    onClose: () => void;
    defaultType?: RequestType;
    affectedPage?: string;
}
declare function RequestModal({ opened, onClose, defaultType, affectedPage }: RequestModalProps): react_jsx_runtime.JSX.Element;

interface RequestButtonProps extends Omit<ButtonProps, 'onClick' | 'leftSection'> {
    label?: string;
    affectedPage?: string;
}
declare function RequestButton({ label, affectedPage, ...buttonProps }: RequestButtonProps): react_jsx_runtime.JSX.Element;

interface RequestActionIconProps {
    tooltip?: string;
    affectedPage?: string;
}
declare function RequestActionIcon({ tooltip, affectedPage }: RequestActionIconProps): react_jsx_runtime.JSX.Element;

export { RequestActionIcon, RequestButton, RequestModal, RequestTypeBadge, RequestsDetailPage, RequestsListPage, SeverityBadge, StatusBadge, StatusTransitionMenu, requestTopbarActionManifest, submittedRequestsManifest };
export type { RequestActionIconProps, RequestButtonProps, RequestModalProps, StatusTransitionMenuProps };
