meyi-insight-ui-dev 1.0.0 → 1.0.2

package/dist/InsightPage.d.ts

@@ -3,5 +3,6 @@ export interface InsightPageProps {
     token?: string;
     basePath?: string;
     userRole?: string;
+    userId?: string;
 }
-export declare function InsightPage({ apiBase, token, basePath }: InsightPageProps): import("react/jsx-runtime").JSX.Element;
+export declare function InsightPage({ apiBase, token, basePath, userRole, userId }: InsightPageProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/common/AssignUsersDialog.d.ts

@@ -0,0 +1,8 @@
+interface Props {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    assigneeIds?: string[];
+    onAssign: (ids: string[]) => Promise<void>;
+}
+export declare function AssignUsersDialog({ open, onOpenChange, assigneeIds, onAssign }: Props): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/components/common/AssigneeSelect.d.ts

@@ -0,0 +1,7 @@
+interface AssigneeSelectProps {
+    assigneeIds?: string[];
+    className?: string;
+    onAssign?: (ids: string[]) => Promise<void>;
+}
+export declare function AssigneeSelect({ assigneeIds, className }: AssigneeSelectProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/bulk-actions.d.ts

@@ -0,0 +1,18 @@
+import { Table } from '@tanstack/react-table';
+type DataTableBulkActionsProps<TData> = {
+    table: Table<TData>;
+    entityName: string;
+    children: React.ReactNode;
+};
+/**
+ * A modular toolbar for displaying bulk actions when table rows are selected.
+ *
+ * @template TData The type of data in the table.
+ * @param {object} props The component props.
+ * @param {Table<TData>} props.table The react-table instance.
+ * @param {string} props.entityName The name of the entity being acted upon (e.g., "task", "user").
+ * @param {React.ReactNode} props.children The action buttons to be rendered inside the toolbar.
+ * @returns {React.ReactNode | null} The rendered component or null if no rows are selected.
+ */
+export declare function DataTableBulkActions<TData>({ table, entityName, children, }: DataTableBulkActionsProps<TData>): React.ReactNode | null;
+export {};

package/dist/components/data-table/column-header.d.ts

@@ -0,0 +1,7 @@
+import { Column } from '@tanstack/react-table';
+type DataTableColumnHeaderProps<TData, TValue> = React.HTMLAttributes<HTMLDivElement> & {
+    column: Column<TData, TValue>;
+    title: string;
+};
+export declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/faceted-filter.d.ts

@@ -0,0 +1,15 @@
+import { Column } from '@tanstack/react-table';
+import * as React from 'react';
+type DataTableFacetedFilterProps<TData, TValue> = {
+    column?: Column<TData, TValue>;
+    title?: string;
+    options: {
+        label: string;
+        value: string;
+        icon?: React.ComponentType<{
+            className?: string;
+        }>;
+    }[];
+};
+export declare function DataTableFacetedFilter<TData, TValue>({ column, title, options, }: DataTableFacetedFilterProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/index.d.ts

@@ -0,0 +1,6 @@
+export { DataTablePagination } from './pagination';
+export { DataTableColumnHeader } from './column-header';
+export { DataTableFacetedFilter } from './faceted-filter';
+export { DataTableViewOptions } from './view-options';
+export { DataTableToolbar } from './toolbar';
+export { DataTableBulkActions } from './bulk-actions';

package/dist/components/data-table/pagination.d.ts

@@ -0,0 +1,7 @@
+import { Table } from '@tanstack/react-table';
+type DataTablePaginationProps<TData> = {
+    table: Table<TData>;
+    className?: string;
+};
+export declare function DataTablePagination<TData>({ table, className, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/toolbar.d.ts

@@ -0,0 +1,18 @@
+import { Table } from '@tanstack/react-table';
+type DataTableToolbarProps<TData> = {
+    table: Table<TData>;
+    searchPlaceholder?: string;
+    filters?: {
+        columnId: string;
+        title: string;
+        options: {
+            label: string;
+            value: string;
+            icon?: React.ComponentType<{
+                className?: string;
+            }>;
+        }[];
+    }[];
+};
+export declare function DataTableToolbar<TData>({ table, searchPlaceholder, filters, }: DataTableToolbarProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/data-table/view-options.d.ts

@@ -0,0 +1,6 @@
+import { Table } from '@tanstack/react-table';
+type DataTableViewOptionsProps<TData> = {
+    table: Table<TData>;
+};
+export declare function DataTableViewOptions<TData>({ table, }: DataTableViewOptionsProps<TData>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import * as AlertDialogPrimitive from '@radix-ui/react-alert-dialog';
+declare function AlertDialog({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTrigger({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogPortal({ ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Overlay>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogContent({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<'div'>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Action>): import("react/jsx-runtime").JSX.Element;
+declare function AlertDialogCancel({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Cancel>): import("react/jsx-runtime").JSX.Element;
+export { AlertDialog, AlertDialogPortal, AlertDialogOverlay, AlertDialogTrigger, AlertDialogContent, AlertDialogHeader, AlertDialogFooter, AlertDialogTitle, AlertDialogDescription, AlertDialogAction, AlertDialogCancel, };

package/dist/components/ui/checkbox.d.ts

@@ -0,0 +1,4 @@
+import * as React from "react";
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox";
+declare const Checkbox: React.ForwardRefExoticComponent<Omit<CheckboxPrimitive.CheckboxProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Checkbox };

package/dist/components/ui/command.d.ts

@@ -0,0 +1,18 @@
+import { Command as CommandPrimitive } from 'cmdk';
+import { Dialog } from './dialog';
+import * as React from 'react';
+declare function Command({ className, ...props }: React.ComponentProps<typeof CommandPrimitive>): import("react/jsx-runtime").JSX.Element;
+declare function CommandDialog({ title, description, children, className, showCloseButton, ...props }: React.ComponentProps<typeof Dialog> & {
+    title?: string;
+    description?: string;
+    className?: string;
+    showCloseButton?: boolean;
+}): import("react/jsx-runtime").JSX.Element;
+declare function CommandInput({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Input>): import("react/jsx-runtime").JSX.Element;
+declare function CommandList({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.List>): import("react/jsx-runtime").JSX.Element;
+declare function CommandEmpty({ ...props }: React.ComponentProps<typeof CommandPrimitive.Empty>): import("react/jsx-runtime").JSX.Element;
+declare function CommandGroup({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function CommandSeparator({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function CommandItem({ className, ...props }: React.ComponentProps<typeof CommandPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function CommandShortcut({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+export { Command, CommandDialog, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandShortcut, CommandSeparator, };

package/dist/components/ui/dropdown-menu.d.ts

@@ -1,21 +1,25 @@
-import * as React from "react";
-import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
-declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
-declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
-declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
-declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
-declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+import * as React from 'react';
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+declare function DropdownMenu({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuPortal({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Portal>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuTrigger({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuContent({ className, sideOffset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuItem({ className, inset, variant, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Item> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    variant?: 'default' | 'destructive';
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuCheckboxItem({ className, children, checked, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.CheckboxItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioGroup({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioGroup>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuRadioItem({ className, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.RadioItem>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuLabel({ className, inset, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Label> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSeparator({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuShortcut({ className, ...props }: React.ComponentProps<'span'>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSub({ ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.Sub>): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubTrigger({ className, inset, children, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubTrigger> & {
     inset?: boolean;
-} & React.RefAttributes<HTMLDivElement>>;
-declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
-export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };
+}): import("react/jsx-runtime").JSX.Element;
+declare function DropdownMenuSubContent({ className, ...props }: React.ComponentProps<typeof DropdownMenuPrimitive.SubContent>): import("react/jsx-runtime").JSX.Element;
+export { DropdownMenu, DropdownMenuPortal, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuGroup, DropdownMenuLabel, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioGroup, DropdownMenuRadioItem, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuSub, DropdownMenuSubTrigger, DropdownMenuSubContent, };

package/dist/components/ui/popover.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+declare function Popover({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverTrigger({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverContent({ className, align, sideOffset, ...props }: React.ComponentProps<typeof PopoverPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function PopoverAnchor({ ...props }: React.ComponentProps<typeof PopoverPrimitive.Anchor>): import("react/jsx-runtime").JSX.Element;
+export { Popover, PopoverTrigger, PopoverContent, PopoverAnchor };

package/dist/components/ui/select.d.ts

@@ -0,0 +1,15 @@
+import * as React from 'react';
+import * as SelectPrimitive from '@radix-ui/react-select';
+declare function Select({ ...props }: React.ComponentProps<typeof SelectPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function SelectGroup({ ...props }: React.ComponentProps<typeof SelectPrimitive.Group>): import("react/jsx-runtime").JSX.Element;
+declare function SelectValue({ ...props }: React.ComponentProps<typeof SelectPrimitive.Value>): import("react/jsx-runtime").JSX.Element;
+declare function SelectTrigger({ className, size, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Trigger> & {
+    size?: 'sm' | 'default';
+}): import("react/jsx-runtime").JSX.Element;
+declare function SelectContent({ className, children, position, ...props }: React.ComponentProps<typeof SelectPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+declare function SelectLabel({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Label>): import("react/jsx-runtime").JSX.Element;
+declare function SelectItem({ className, children, ...props }: React.ComponentProps<typeof SelectPrimitive.Item>): import("react/jsx-runtime").JSX.Element;
+declare function SelectSeparator({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.Separator>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollUpButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollUpButton>): import("react/jsx-runtime").JSX.Element;
+declare function SelectScrollDownButton({ className, ...props }: React.ComponentProps<typeof SelectPrimitive.ScrollDownButton>): import("react/jsx-runtime").JSX.Element;
+export { Select, SelectContent, SelectGroup, SelectItem, SelectLabel, SelectScrollDownButton, SelectScrollUpButton, SelectSeparator, SelectTrigger, SelectValue, };

package/dist/components/ui/switch.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import * as SwitchPrimitive from '@radix-ui/react-switch';
+declare const Switch: React.ForwardRefExoticComponent<Omit<SwitchPrimitive.SwitchProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+export { Switch };

package/dist/components/ui/textarea.d.ts

@@ -0,0 +1,5 @@
+import * as React from "react";
+export interface TextareaProps extends React.TextareaHTMLAttributes<HTMLTextAreaElement> {
+}
+declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export { Textarea };

package/dist/components/ui/tooltip.d.ts

@@ -0,0 +1,7 @@
+import * as React from 'react';
+import * as TooltipPrimitive from '@radix-ui/react-tooltip';
+declare function TooltipProvider({ delayDuration, ...props }: React.ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+declare function Tooltip({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipTrigger({ ...props }: React.ComponentProps<typeof TooltipPrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
+declare function TooltipContent({ className, sideOffset, children, ...props }: React.ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export { Tooltip, TooltipTrigger, TooltipContent, TooltipProvider };

package/dist/context.d.ts

@@ -0,0 +1,14 @@
+import { default as React } from 'react';
+interface InsightContextValue {
+    userRole: string;
+    userId: string;
+    isAdmin: boolean;
+    isReadOnly: boolean;
+}
+export declare const useInsightContext: () => InsightContextValue;
+export declare function InsightProvider({ role, userId, children }: {
+    role: string;
+    userId: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/alerts/components/AlertForm.d.ts

@@ -0,0 +1,15 @@
+import { InsightAlert } from '../../../types.js';
+interface AlertFormProps {
+    open: boolean;
+    alert: InsightAlert | null;
+    submitting: boolean;
+    onClose: () => void;
+    onSubmit: (data: {
+        alertName: string;
+        description?: string;
+        severity?: string;
+        projectTag?: string;
+    }) => void;
+}
+export declare function AlertForm({ open, alert, submitting, onClose, onSubmit }: AlertFormProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/alerts/components/{PromoteDialog.d.ts → ConvertDialog.d.ts}

@@ -1,8 +1,8 @@
 import { InsightAlert } from '../../../types.js';
-export declare function PromoteDialog({ alert, open, onConfirm, onCancel, promoting, }: {
+export declare function ConvertDialog({ alert, open, onConfirm, onCancel, converting, }: {
     alert: InsightAlert | null;
     open: boolean;
     onConfirm: () => void;
     onCancel: () => void;
-    promoting: boolean;
+    converting: boolean;
 }): import("react/jsx-runtime").JSX.Element;

package/dist/features/alerts/components/InsightAlertCard.d.ts

@@ -3,8 +3,11 @@ interface InsightAlertCardProps {
     alert: InsightAlert;
     deletingId: string | null;
     onViewIncident: (id: string) => void;
-    onPromote: (alert: InsightAlert) => void;
+    onConvert: (alert: InsightAlert) => void;
+    onGenerateSop?: (alert: InsightAlert) => void;
+    generatingSopId?: string | null;
+    sopId?: string | null;
     onDelete: (id: string) => void;
 }
-export declare function InsightAlertCard({ alert, deletingId, onViewIncident, onPromote, onDelete, }: InsightAlertCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function InsightAlertCard({ alert, deletingId, onViewIncident, onConvert, onGenerateSop, generatingSopId, sopId, onDelete, }: InsightAlertCardProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/features/alerts/components/alerts-columns.d.ts

@@ -0,0 +1,11 @@
+import { ColumnDef } from '@tanstack/react-table';
+import { InsightAlert } from '../../../types.js';
+export declare const getAlertsColumns: (actions: {
+    onEdit: (alert: InsightAlert) => void;
+    onViewIncident: (id: string) => void;
+    onDelete: (id: string) => void;
+    onConvert: (alert: InsightAlert) => void;
+    onGenerateSop?: (alert: InsightAlert) => void;
+    generatingSopId?: string | null;
+    sopsByAlertName?: Record<string, string>;
+}) => ColumnDef<InsightAlert>[];

package/dist/features/alerts/components/alerts-table.d.ts

@@ -0,0 +1,25 @@
+import { InsightAlert, InsightConnector } from '../../../types.js';
+interface AlertsTableProps {
+    data: InsightAlert[];
+    total: number;
+    page: number;
+    limit: number;
+    onPageChange: (page: number) => void;
+    onLimitChange: (limit: number) => void;
+    onViewIncident: (id: string) => void;
+    onEdit: (alert: InsightAlert) => void;
+    onDelete: (id: string) => void;
+    onConvert: (alert: InsightAlert) => void;
+    onGenerateSop?: (alert: InsightAlert) => void;
+    generatingSopId?: string | null;
+    sopsByAlertName?: Record<string, string>;
+    search: string;
+    onSearchChange: (search: string) => void;
+    severityFilter: string;
+    onSeverityChange: (severity: string) => void;
+    connectorFilter: string;
+    onConnectorChange: (connectorId: string) => void;
+    connectors: InsightConnector[];
+}
+export declare function AlertsTable({ data, total, page, limit, onPageChange, onLimitChange, onViewIncident, onEdit, onDelete, onConvert, onGenerateSop, generatingSopId, sopsByAlertName, search, onSearchChange, severityFilter, onSeverityChange, connectorFilter, onConnectorChange, connectors, }: AlertsTableProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/cloudwatch-wizard/CloudWatchConnectorWizard.d.ts

@@ -0,0 +1,8 @@
+import { InsightConnector } from '../../../types.js';
+export declare function CloudWatchConnectorWizard({ open, onOpenChange, onCreated, connector, onAccessKeyDeploy, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreated: () => void;
+    connector?: InsightConnector | null;
+    onAccessKeyDeploy?: (connector: InsightConnector) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/features/connectors/components/ConnectorAwsOnboardingDialog.d.ts

@@ -0,0 +1,41 @@
+import { InsightCloudWatchDeployResult, InsightCloudWatchDiscoverResult } from '../../../types.js';
+interface Props {
+    open: boolean;
+    loadingDiscover?: boolean;
+    deploying?: boolean;
+    discoveringReady: boolean;
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken: string;
+        region: string;
+        stackName: string;
+    };
+    naming: {
+        lambdaName: string;
+        alarmNamePrefix: string;
+    };
+    alarmDefaults: {
+        threshold: string;
+        period: string;
+        evaluationPeriods: string;
+        statistic: string;
+        comparisonOperator: string;
+        treatMissingData: string;
+    };
+    selectedAlarmNames: string[];
+    selectedMetricKeys: string[];
+    discoverData: InsightCloudWatchDiscoverResult | null;
+    deployData: InsightCloudWatchDeployResult | null;
+    templateDownloadUrl: string | null;
+    onChangeCredentials: (next: Partial<Props["credentials"]>) => void;
+    onChangeNaming: (next: Partial<Props["naming"]>) => void;
+    onChangeAlarmDefaults: (next: Partial<Props["alarmDefaults"]>) => void;
+    onToggleAlarm: (alarmName: string, checked: boolean) => void;
+    onToggleMetric: (metricKey: string, checked: boolean) => void;
+    onDiscover: () => Promise<void>;
+    onDeploy: () => Promise<void>;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ConnectorAwsOnboardingDialog({ open, loadingDiscover, deploying, discoveringReady, credentials, naming, alarmDefaults, selectedAlarmNames, selectedMetricKeys, discoverData, deployData, templateDownloadUrl, onChangeCredentials, onChangeNaming, onChangeAlarmDefaults, onToggleAlarm, onToggleMetric, onDiscover, onDeploy, onOpenChange, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/ConnectorDatadogSetupDialog.d.ts

@@ -0,0 +1,21 @@
+import { InsightDatadogOnboarding, InsightDatadogSetupResult } from '../../../types.js';
+interface ConnectorDatadogSetupDialogProps {
+    open: boolean;
+    loading?: boolean;
+    configuring?: boolean;
+    data: InsightDatadogOnboarding | null;
+    result?: InsightDatadogSetupResult | null;
+    site: string;
+    webhookName: string;
+    datadogApiKey: string;
+    datadogAppKey: string;
+    onSiteChange: (value: string) => void;
+    onWebhookNameChange: (value: string) => void;
+    onDatadogApiKeyChange: (value: string) => void;
+    onDatadogAppKeyChange: (value: string) => void;
+    onRefresh: () => Promise<void>;
+    onConfigure: () => Promise<void>;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ConnectorDatadogSetupDialog({ open, loading, configuring, data, result, site, webhookName, datadogApiKey, datadogAppKey, onSiteChange, onWebhookNameChange, onDatadogApiKeyChange, onDatadogAppKeyChange, onRefresh, onConfigure, onOpenChange, }: ConnectorDatadogSetupDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/ConnectorDetailsDialog.d.ts

@@ -0,0 +1,8 @@
+import { InsightConnector } from '../../../types.js';
+interface ConnectorDetailsDialogProps {
+    open: boolean;
+    connector: InsightConnector | null;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ConnectorDetailsDialog({ open, connector, onOpenChange }: ConnectorDetailsDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/ConnectorFilters.d.ts

@@ -0,0 +1,18 @@
+import { InsightConnectorType } from '../../../types.js';
+export type ConnectorFiltersState = {
+    sourceTypes: InsightConnectorType[];
+};
+interface Props {
+    search: string;
+    filters: ConnectorFiltersState;
+    loading?: boolean;
+    onSearchChange: (value: string) => void;
+    onFiltersChange: (filters: ConnectorFiltersState) => void;
+    onRefresh: () => void;
+    onAdd: () => void;
+}
+export declare function getDefaultConnectorFilters(): {
+    sourceTypes: InsightConnectorType[];
+};
+export declare function ConnectorFilters({ search, filters, loading, onSearchChange, onFiltersChange, onRefresh, onAdd, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/ConnectorGrafanaSetupDialog.d.ts

@@ -0,0 +1,25 @@
+import { InsightGrafanaOnboarding, InsightGrafanaSetupResult } from '../../../types.js';
+interface ConnectorGrafanaSetupDialogProps {
+    open: boolean;
+    loading?: boolean;
+    configuring?: boolean;
+    data: InsightGrafanaOnboarding | null;
+    result?: InsightGrafanaSetupResult | null;
+    grafanaBaseUrl: string;
+    grafanaToken: string;
+    contactPointName: string;
+    autoRoute: boolean;
+    matcherLabel: string;
+    matcherValue: string;
+    onGrafanaBaseUrlChange: (value: string) => void;
+    onGrafanaTokenChange: (value: string) => void;
+    onContactPointNameChange: (value: string) => void;
+    onAutoRouteChange: (value: boolean) => void;
+    onMatcherLabelChange: (value: string) => void;
+    onMatcherValueChange: (value: string) => void;
+    onRefresh: () => Promise<void>;
+    onConfigure: () => Promise<void>;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ConnectorGrafanaSetupDialog({ open, loading, configuring, data, result, grafanaBaseUrl, grafanaToken, contactPointName, autoRoute, matcherLabel, matcherValue, onGrafanaBaseUrlChange, onGrafanaTokenChange, onContactPointNameChange, onAutoRouteChange, onMatcherLabelChange, onMatcherValueChange, onRefresh, onConfigure, onOpenChange, }: ConnectorGrafanaSetupDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/ConnectorPrometheusSetupDialog.d.ts

@@ -0,0 +1,20 @@
+import { InsightPrometheusOnboarding } from '../../../types.js';
+interface ConnectorPrometheusSetupDialogProps {
+    open: boolean;
+    loading?: boolean;
+    data: InsightPrometheusOnboarding | null;
+    prometheusBaseUrl: string;
+    alertmanagerBaseUrl: string;
+    checkingStatus?: boolean;
+    statusResult?: {
+        status: string;
+        reason: string;
+    } | null;
+    onPrometheusBaseUrlChange: (value: string) => void;
+    onAlertmanagerBaseUrlChange: (value: string) => void;
+    onCheckStatus: () => Promise<void>;
+    onRefresh: () => Promise<void>;
+    onOpenChange: (open: boolean) => void;
+}
+export declare function ConnectorPrometheusSetupDialog({ open, loading, data, prometheusBaseUrl, alertmanagerBaseUrl, checkingStatus, statusResult, onPrometheusBaseUrlChange, onAlertmanagerBaseUrlChange, onCheckStatus, onRefresh, onOpenChange, }: ConnectorPrometheusSetupDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/ConnectorTokenPolicyDialog.d.ts

@@ -0,0 +1,11 @@
+import { InsightConnector } from '../../../types.js';
+interface ConnectorTokenPolicyDialogProps {
+    open: boolean;
+    connector: InsightConnector | null;
+    loading?: boolean;
+    submitting?: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSubmit: (mode: "expires" | "unlimited", ttlDays?: number) => Promise<void>;
+}
+export declare function ConnectorTokenPolicyDialog({ open, connector, loading, submitting, onOpenChange, onSubmit, }: ConnectorTokenPolicyDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/connectors/components/InsightConnectorCard.d.ts

@@ -3,9 +3,15 @@ interface InsightConnectorCardProps {
     connector: InsightConnector;
     deletingId: string | null;
     rotatingId: string | null;
+    onView: (connector: InsightConnector) => void;
     onEdit: (connector: InsightConnector) => void;
     onRotate: (id: string) => void;
     onDelete: (id: string) => void;
+    onManageTokenPolicy: (connector: InsightConnector) => void;
+    onAwsSetup: (connector: InsightConnector) => void;
+    onGrafanaSetup: (connector: InsightConnector) => void;
+    onPrometheusSetup: (connector: InsightConnector) => void;
+    onDatadogSetup: (connector: InsightConnector) => void;
 }
-export declare function InsightConnectorCard({ connector, deletingId, rotatingId, onEdit, onRotate, onDelete, }: InsightConnectorCardProps): import("react/jsx-runtime").JSX.Element;
+export declare function InsightConnectorCard({ connector, deletingId, rotatingId, onView, onEdit, onRotate, onDelete, onManageTokenPolicy, onAwsSetup, onGrafanaSetup, onPrometheusSetup, onDatadogSetup, }: InsightConnectorCardProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/features/connectors/components/InsightConnectorForm.d.ts

@@ -12,6 +12,7 @@ interface InsightConnectorFormProps {
     onSubmit: (name: string, type: InsightConnectorType, description?: string) => void;
     createdWebhookUrl?: string | null;
     onWebhookModalClose?: () => void;
+    initialType?: InsightConnectorType | null;
 }
-export declare function InsightConnectorForm({ open, connector, submitting, onClose, onSubmit, createdWebhookUrl, onWebhookModalClose, }: InsightConnectorFormProps): import("react/jsx-runtime").JSX.Element;
+export declare function InsightConnectorForm({ open, connector, submitting, onClose, onSubmit, createdWebhookUrl, onWebhookModalClose, initialType, }: InsightConnectorFormProps): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/features/connectors/grafana-wizard/GrafanaConnectorWizard.d.ts

@@ -0,0 +1,7 @@
+import { InsightConnector } from '../../../types.js';
+export declare function GrafanaConnectorWizard({ open, connector, onOpenChange, onCreated, }: {
+    open: boolean;
+    connector?: InsightConnector | null;
+    onOpenChange: (open: boolean) => void;
+    onCreated: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/features/connectors/prometheus-wizard/PrometheusConnectorWizard.d.ts

@@ -0,0 +1,5 @@
+export declare function PrometheusConnectorWizard({ open, onOpenChange, onCreated, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onCreated: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/features/connectors/source-selection/ConnectorSourcePickerDialog.d.ts

@@ -0,0 +1,6 @@
+import { InsightConnectorType } from '../../../types.js';
+export declare function ConnectorSourcePickerDialog({ open, onOpenChange, onSelect, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSelect: (type: InsightConnectorType) => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/features/incidents/components/IncidentComments.d.ts

@@ -0,0 +1,9 @@
+import { InsightIncidentComment } from '../../../types.js';
+interface Props {
+    comments?: InsightIncidentComment[];
+    readOnly?: boolean;
+    submitting?: boolean;
+    onSubmit: (message: string) => Promise<void>;
+}
+export declare function IncidentComments({ comments, readOnly, submitting, onSubmit }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/incidents/components/IncidentDeleteDialog.d.ts

@@ -0,0 +1,8 @@
+interface IncidentDeleteDialogProps {
+    open: boolean;
+    onConfirm: () => void;
+    onCancel: () => void;
+    deleting: boolean;
+}
+export declare function IncidentDeleteDialog({ open, onConfirm, onCancel, deleting }: IncidentDeleteDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/incidents/components/IncidentFilters.d.ts

@@ -0,0 +1,18 @@
+export type IncidentFiltersState = {
+    statuses: string[];
+    assigneeIds: string[];
+};
+interface Props {
+    search: string;
+    filters: IncidentFiltersState;
+    loading?: boolean;
+    onSearchChange: (value: string) => void;
+    onFiltersChange: (filters: IncidentFiltersState) => void;
+    onRefresh: () => void;
+}
+export declare function getDefaultIncidentFilters(): {
+    statuses: string[];
+    assigneeIds: string[];
+};
+export declare function IncidentFilters({ search, filters, loading, onSearchChange, onFiltersChange, onRefresh, }: Props): import("react/jsx-runtime").JSX.Element;
+export {};