react-semaphor 0.1.204 → 0.1.206

package/dist/types/main.d.ts

@@ -1,19 +1,23 @@
 import { Chart as Chart_2 } from 'chart.js';
 import { ChartConfiguration } from 'chart.js';
+import { ClassProp } from 'class-variance-authority/types';
 import { ColumnSizingState } from '@tanstack/react-table';
 import { DateRange } from 'react-day-picker';
 import { default as default_2 } from 'react-grid-layout';
+import { FetchStatus } from '@tanstack/react-query';
 import { FontSpec } from 'chart.js';
 import { JSX } from 'react/jsx-runtime';
 import { JSX as JSX_2 } from 'react';
-import { QueryObserverResult } from '@tanstack/query-core';
+import { QueryObserverResult } from '@tanstack/react-query';
 import * as React_2 from 'react';
-import { RefetchOptions } from '@tanstack/query-core';
+import { RefetchOptions } from '@tanstack/react-query';
 import { StoreApi } from 'zustand';
 import { UseBoundStore } from 'zustand';
 import { UseMutateAsyncFunction } from '@tanstack/react-query';
 import { UseMutateFunction } from '@tanstack/react-query';
+import { UseMutationResult } from '@tanstack/react-query';
 import { UseQueryResult } from '@tanstack/react-query';
+import { VariantProps } from 'class-variance-authority';
 import { WritableDraft } from 'immer';
 
 declare type Actions = {
@@ -303,6 +307,248 @@ export declare type AIScopeTable = {
     datamodelName: string;
 };
 
+export declare interface Alert {
+    id: string;
+    kind?: 'ALERT';
+    name: string;
+    description?: string | null;
+    status: AlertStatus;
+    scheduleExpr: string;
+    timezone: string;
+    nextRunAt?: string | null;
+    lastRunAt?: string | null;
+    lastRunStatus?: string | null;
+    sourceHealth?: 'OK' | 'SOURCE_MISSING' | 'SOURCE_ERROR' | 'STALE';
+    alertState?: AlertState | null;
+    jobConfig: AlertJobConfig;
+    deliveryConfig: {
+        recipients: AlertRecipient[];
+        channels: AlertDeliveryChannel[];
+        subject?: string;
+        message?: string;
+    };
+    createdAt: string;
+    updatedAt: string;
+}
+
+export declare interface AlertBacktestResult {
+    ruleId?: string;
+    evaluationCount: number;
+    transitionsWithoutDampening: number;
+    transitionsWithDampening: number;
+    recommendation?: string | null;
+    firingEpisodes?: Array<{
+        triggeredAt: string;
+        recoveredAt: string | null;
+        durationMinutes: number;
+        peakValue: number;
+    }>;
+}
+
+export declare type AlertConditionOperator = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'neq' | 'pct_change_gt' | 'pct_change_lt';
+
+export declare type AlertContextAuthoringMode = 'basic' | 'conversational' | 'manual';
+
+export declare interface AlertContextInterpretResponse {
+    workflowDef: Record<string, unknown>;
+    contextSources: ContextSource[];
+    explanation?: string;
+}
+
+export declare type AlertContextSourceKind = 'trend_window' | 'peer_comparison' | 'related_metric' | 'breakdown' | 'custom_query';
+
+export declare function AlertCreationDialog({ open, onOpenChange, prefilledSource, prefilledSeries, onCreated, contextBuilderEnabled, }: AlertCreationDialogProps): JSX.Element;
+
+declare type AlertCreationDialogProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    prefilledSource?: AlertSource;
+    prefilledSeries?: BacktestPoint[];
+    onCreated?: (alertId: string) => void;
+    contextBuilderEnabled?: boolean;
+};
+
+export declare interface AlertDeliverablePreview {
+    mode: 'standard_fallback' | 'custom';
+    html: string;
+    warnings?: string[];
+}
+
+export declare type AlertDeliveryChannel = 'EMAIL' | 'WEBHOOK' | 'SLACK' | 'IN_APP';
+
+declare type AlertDraft = Partial<CreateAlertRequest> & {
+    contextSources?: ContextSource[];
+    presentationPrompt?: string;
+};
+
+declare type AlertFilters = {
+    status: 'all' | 'ACTIVE' | 'PAUSED' | 'DISABLED';
+    query: string;
+};
+
+export declare interface AlertHistoryResponse {
+    ruleId: string;
+    windowDays: number;
+    totalFirings: number;
+    averageFiringDurationMinutes: number;
+    longestFiring: {
+        triggeredAt: string;
+        recoveredAt: string | null;
+        durationMinutes: number;
+        triggerValue: number | null;
+        recoveryValue: number | null;
+    } | null;
+    shortestFiring: {
+        triggeredAt: string;
+        recoveredAt: string | null;
+        durationMinutes: number;
+        triggerValue: number | null;
+        recoveryValue: number | null;
+    } | null;
+    totalFiringMinutes: number;
+    firingPercentage: number;
+    episodes: Array<{
+        triggeredAt: string;
+        recoveredAt: string | null;
+        durationMinutes: number;
+        triggerValue: number | null;
+        recoveryValue: number | null;
+    }>;
+}
+
+export declare type AlertJobConfig = {
+    kind: 'ALERT';
+    source: AlertSource;
+    operator: AlertConditionOperator;
+    threshold: number;
+    severity: AlertSeverity;
+    consecutiveCount?: number;
+    notifyPolicy: 'on_state_change';
+    contextAuthoringMode?: AlertContextAuthoringMode;
+    contextSources?: ContextSource[];
+    presentationPrompt?: string;
+};
+
+export declare function AlertManagementPage({ scope, prefilledSource, }: AlertManagementPageProps): JSX.Element;
+
+declare type AlertManagementPageProps = {
+    scope?: AlertManagementScope;
+    prefilledSource?: AlertSource;
+};
+
+declare type AlertManagementScope = {
+    dashboardId?: string;
+    cardId?: string;
+};
+
+export declare interface AlertQuotaPolicy {
+    maxActiveAlerts: number;
+    minCadenceMinutes: number;
+    maxContextSources: number;
+}
+
+export declare interface AlertQuotaRecord {
+    tenantId: string | null;
+    policy: AlertQuotaPolicy;
+    activeAlerts: number;
+}
+
+export declare type AlertRecipient = {
+    type: 'email';
+    address: string;
+    name?: string;
+} | {
+    type: 'user';
+    userId: string;
+} | {
+    type: 'tenant_user';
+    tenantUserId: string;
+} | {
+    type: 'group';
+    groupId: string;
+};
+
+export declare interface AlertRun {
+    id: string;
+    ruleId: string;
+    status: 'QUEUED' | 'RUNNING' | 'SUCCESS' | 'FAILED';
+    scheduledFor: string;
+    startedAt?: string | null;
+    completedAt?: string | null;
+    error?: string | null;
+    result?: Record<string, unknown> | null;
+}
+
+export declare class AlertsApiError extends Error {
+    readonly status: number;
+    readonly details?: unknown | undefined;
+    constructor(message: string, status: number, details?: unknown | undefined);
+}
+
+export declare type AlertSeverity = 'LOW' | 'MEDIUM' | 'HIGH' | 'CRITICAL';
+
+export declare type AlertSource = {
+    type: 'saved_metric';
+    metricId: string;
+    title?: string;
+} | {
+    type: 'dashboard_metric';
+    dashboardId: string;
+    visualId: string;
+    cardId: string;
+    title?: string;
+    executionSnapshot: {
+        queryConfig: Record<string, unknown>;
+        filterContext: Record<string, unknown>;
+        formattingContext: Record<string, unknown>;
+        connectionId: string;
+        calendarContext?: {
+            tz: string;
+            weekStart: number;
+        };
+    };
+};
+
+export declare interface AlertState {
+    currentState: AlertStateValue;
+    lastEvaluatedAt?: string | null;
+    lastValue?: string | null;
+    lastTriggeredAt?: string | null;
+    lastRecoveredAt?: string | null;
+    consecutiveTrue: number;
+    consecutiveFalse: number;
+    firingDurationMinutes?: number | null;
+}
+
+export declare type AlertStateValue = 'OK' | 'FIRING';
+
+export declare type AlertStatus = 'ACTIVE' | 'PAUSED' | 'DISABLED';
+
+export declare type AlertStore = AlertStoreState & {
+    actions: AlertStoreActions;
+};
+
+declare type AlertStoreActions = {
+    upsertAlerts: (alerts: Alert[]) => void;
+    upsertAlert: (alert: Alert) => void;
+    removeAlert: (id: string) => void;
+    selectAlert: (id: string | null) => void;
+    setCreateDialogOpen: (open: boolean) => void;
+    setFilters: (filters: Partial<AlertFilters>) => void;
+    setDraft: (draft: Partial<AlertDraft>) => void;
+    resetDraft: () => void;
+    patchAlert: (id: string, patch: UpdateAlertRequest) => void;
+};
+
+declare type AlertStoreState = {
+    alertsById: Record<string, Alert>;
+    cardAlertMap: Map<string, string[]>;
+    selectedAlertId: string | null;
+    createDialogOpen: boolean;
+    filters: AlertFilters;
+    draft: AlertDraft;
+};
+
 export declare type AssistantId = 'dashboard-assistant' | 'editor-assistant';
 
 export declare type AuthToken = {
@@ -348,6 +594,13 @@ export declare type AxisConfig = {
     };
 };
 
+export declare function backtestAlert(apiServiceUrl: string, token: string, id: string | undefined, payload?: Record<string, unknown>): Promise<AlertBacktestResult>;
+
+declare type BacktestPoint = {
+    at: string;
+    value: number;
+};
+
 export declare interface BaseColumn {
     id: string;
     name: string;
@@ -380,6 +633,15 @@ export declare interface BaseInteractionEvent {
 
 export declare type Breakpoint = 'lg' | 'md' | 'sm' | 'xs' | 'xxs';
 
+declare interface ButtonProps extends React_2.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+    asChild?: boolean;
+}
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "link" | "outline" | "destructive" | "secondary" | "ghost" | null | undefined;
+    size?: "default" | "lg" | "sm" | "icon" | null | undefined;
+} & ClassProp) | undefined) => string;
+
 export declare type CacheConfig = {
     ttl: string;
     status: 'on' | 'on-refresh' | 'off';
@@ -492,6 +754,12 @@ declare interface CalendarPreferencesDialogProps {
  */
 export declare function cancelExport(apiServiceUrl: string, token: string, exportId: string): Promise<void>;
 
+export declare function CardAlertIndicator({ cardId }: CardAlertIndicatorProps): JSX.Element | null;
+
+declare type CardAlertIndicatorProps = {
+    cardId: string;
+};
+
 export declare interface CardConfig {
     groupByColumns?: GroupByField[];
     metricColumns?: MetricField[];
@@ -770,6 +1038,35 @@ export declare type ConnectionType = 'GoogleSheets' | 'FileUpload' | 'MySQL' | '
 
 export declare type ContainerId = 'groupBy' | 'metrics' | 'pivotBy' | 'sortBy' | 'detailColumns' | 'source';
 
+export declare type ContextSource = {
+    kind: AlertContextSourceKind;
+    config: Record<string, unknown>;
+    outputAs?: string;
+};
+
+export declare function createAlert(apiServiceUrl: string, token: string, payload: CreateAlertRequest): Promise<{
+    alert: Alert;
+}>;
+
+export declare interface CreateAlertRequest {
+    kind?: 'ALERT';
+    name: string;
+    description?: string;
+    scheduleExpr: string;
+    timezone?: string;
+    source: AlertSource;
+    operator: AlertConditionOperator;
+    threshold: number;
+    severity?: AlertSeverity;
+    consecutiveCount?: number;
+    recipients: AlertRecipient[];
+    channels?: AlertDeliveryChannel[];
+    contextAuthoringMode?: AlertContextAuthoringMode;
+    contextSources?: ContextSource[];
+    presentationPrompt?: string;
+    workflowDef?: Record<string, unknown>;
+}
+
 /**
  * Factory function to create empty KPI card configuration
  * Returns a fresh config with new array instances to prevent shared references
@@ -1039,6 +1336,10 @@ declare type DateUnit = 'day' | 'week' | 'month' | 'quarter' | 'year';
  */
 export declare const DEFAULT_CALENDAR_CONTEXT: CalendarContext;
 
+export declare function deleteAlert(apiServiceUrl: string, token: string, id: string): Promise<{
+    success: boolean;
+}>;
+
 /**
  * Field configuration for detail table columns.
  * Unlike GroupByField, DetailField does not support aggregation or granularity.
@@ -1805,6 +2106,44 @@ export declare interface FormatSpec {
     suffix?: string;
 }
 
+export declare function getAlert(apiServiceUrl: string, token: string, id: string): Promise<{
+    alert: Alert;
+}>;
+
+export declare function getAlertContextSources(apiServiceUrl: string, token: string, alertId: string): Promise<{
+    ruleId: string;
+    contextSources: Array<Record<string, unknown>>;
+}>;
+
+export declare function getAlertHistory(apiServiceUrl: string, token: string, id: string, params?: {
+    windowDays?: 7 | 30 | 90;
+}): Promise<AlertHistoryResponse>;
+
+export declare function getAlertQuotaUsage(apiServiceUrl: string, token: string): Promise<{
+    usage: AlertQuotaRecord[];
+}>;
+
+export declare function getAlertRunDeliveries(apiServiceUrl: string, token: string, id: string, runId: string): Promise<{
+    attempts: Array<Record<string, unknown>>;
+}>;
+
+export declare function getAlertRuns(apiServiceUrl: string, token: string, id: string, params?: {
+    cursor?: string;
+    limit?: number;
+}): Promise<{
+    runs: AlertRun[];
+    nextCursor: string | null;
+    total: number;
+}>;
+
+export declare function getAlertRunSteps(apiServiceUrl: string, token: string, id: string, runId: string): Promise<{
+    steps: Array<Record<string, unknown>>;
+}>;
+
+export declare function getAlertState(apiServiceUrl: string, token: string, id: string): Promise<{
+    state: AlertState;
+}>;
+
 export declare function getColumnDataType(column: TDataColumn): string;
 
 export declare type GetDashboardResponse = {
@@ -2027,6 +2366,11 @@ export declare interface InteractionTrigger {
     field: Field;
 }
 
+export declare function interpretAlertContext(apiServiceUrl: string, token: string, payload: {
+    intent: string;
+    ruleId?: string;
+}): Promise<AlertContextInterpretResponse>;
+
 export declare function invalidateToken(apiServiceUrl: string): Promise<any>;
 
 export declare function isBooleanDataType(dataType: string): boolean;
@@ -2123,6 +2467,20 @@ declare interface LinkFormat {
     openInNewTab: boolean;
 }
 
+export declare function listAlertQuotas(apiServiceUrl: string, token: string): Promise<{
+    quotas: AlertQuotaRecord[];
+}>;
+
+export declare function listAlerts(apiServiceUrl: string, token: string, params?: {
+    status?: string;
+    cursor?: string;
+    limit?: number;
+}): Promise<{
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+}>;
+
 export declare type LoadingProps = {
     message?: string;
 };
@@ -2326,6 +2684,8 @@ export declare type Placeholders = {
 
 export declare type PluginType = 'custom' | 'standard';
 
+export declare function previewAlertDeliverable(apiServiceUrl: string, token: string, payload: Record<string, unknown>, alertId?: string): Promise<AlertDeliverablePreview>;
+
 /**
  * Print state structure exposed to window for Lambda/Puppeteer access.
  */
@@ -2465,8 +2825,9 @@ export declare enum ResourceType {
     VISUAL = "visual"
 }
 
-export declare function ScheduleDashboard({ triggerButtonClassName, }: {
+export declare function ScheduleDashboard({ triggerButtonClassName, variant, }: {
     triggerButtonClassName?: string;
+    variant?: ButtonProps['variant'];
 }): JSX.Element | null;
 
 export declare type SchemaItem = DropdownItem;
@@ -3129,6 +3490,8 @@ export declare type TDbCapabilities = {
     supportsFilterClause?: boolean;
 };
 
+export declare function TenantQuotaPage(): JSX.Element;
+
 export declare type TEvent = {
     type: 'success' | 'error' | 'info' | 'warning';
     message: any;
@@ -3560,6 +3923,11 @@ export declare type TokenSecurityPolicy = {
 /** Point style options supported by Chart.js */
 export declare type TPointStyle = 'circle' | 'cross' | 'crossRot' | 'dash' | 'line' | 'rect' | 'rectRounded' | 'rectRot' | 'star' | 'triangle';
 
+export declare function triggerAlertNow(apiServiceUrl: string, token: string, ruleId: string): Promise<{
+    accepted: boolean;
+    runId?: string;
+}>;
+
 export declare type TSelectedRecord = ComboBoxOption;
 
 export declare type TSheet = {
@@ -3615,6 +3983,39 @@ declare type UnsavedChangesAlertProps = {
     isSaving: boolean;
 };
 
+export declare function updateAlert(apiServiceUrl: string, token: string, id: string, payload: UpdateAlertRequest): Promise<{
+    alert: Alert;
+}>;
+
+export declare function updateAlertContextSources(apiServiceUrl: string, token: string, alertId: string, contextSources: Array<Record<string, unknown>>): Promise<{
+    ruleId: string;
+    contextSources: Array<Record<string, unknown>>;
+    workflowDef: Record<string, unknown>;
+}>;
+
+export declare function updateAlertQuota(apiServiceUrl: string, token: string, tenantId: string, payload: Partial<AlertQuotaRecord['policy']>): Promise<{
+    quota: AlertQuotaRecord;
+}>;
+
+export declare interface UpdateAlertRequest {
+    name?: string;
+    description?: string | null;
+    scheduleExpr?: string;
+    timezone?: string;
+    status?: AlertStatus;
+    source?: AlertSource;
+    operator?: AlertConditionOperator;
+    threshold?: number;
+    severity?: AlertSeverity;
+    consecutiveCount?: number;
+    recipients?: AlertRecipient[];
+    channels?: AlertDeliveryChannel[];
+    contextAuthoringMode?: AlertContextAuthoringMode;
+    contextSources?: ContextSource[];
+    presentationPrompt?: string;
+    workflowDef?: Record<string, unknown> | null;
+}
+
 declare interface UpdateDashboardTemplateRequest {
     template: TDashboard;
 }
@@ -3658,6 +4059,424 @@ export declare interface URLParameter {
 
 export declare const useActiveExports: () => Map<string, ActiveExport>;
 
+export declare const useAlertActions: () => AlertStoreActions;
+
+export declare function useAlertBacktest(alertId?: string): UseMutationResult<AlertBacktestResult, Error, Record<string, unknown> | undefined, unknown>;
+
+export declare function useAlertContextBuilder(ruleId?: string): UseMutationResult<AlertContextInterpretResponse, Error, string, unknown>;
+
+export declare function useAlertDeliveries(alertId: string | undefined, runId: string | undefined): UseQueryResult<    {
+attempts: Array<Record<string, unknown>>;
+}, Error>;
+
+export declare function useAlertDetail(alertId?: string): UseQueryResult<    {
+alert: Alert;
+}, Error>;
+
+export declare const useAlertDraft: () => AlertDraft;
+
+export declare const useAlertFilters: () => AlertFilters;
+
+export declare function useAlertHistory(alertId: string | undefined, windowDays?: 7 | 30 | 90): UseQueryResult<AlertHistoryResponse, Error>;
+
+export declare function useAlertQuotas(): {
+    quotasQuery: UseQueryResult<    {
+    quotas: AlertQuotaRecord[];
+    }, Error>;
+    usageQuery: UseQueryResult<    {
+    usage: AlertQuotaRecord[];
+    }, Error>;
+    updateQuota: UseMutateAsyncFunction<    {
+    quota: AlertQuotaRecord;
+    }, Error, {
+    tenantId: string;
+    policy: {
+    maxActiveAlerts?: number;
+    minCadenceMinutes?: number;
+    maxContextSources?: number;
+    };
+    }, unknown>;
+    isUpdatingQuota: boolean;
+};
+
+export declare function useAlertRuns(alertId: string | undefined, limit?: number): UseQueryResult<    {
+runs: AlertRun[];
+nextCursor: string | null;
+total: number;
+}, Error>;
+
+export declare function useAlerts(options?: {
+    enabled?: boolean;
+    limit?: number;
+}): {
+    alerts: Alert[];
+    createAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, CreateAlertRequest, unknown>;
+    updateAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, {
+    id: string;
+    payload: UpdateAlertRequest;
+    }, unknown>;
+    deleteAlert: UseMutateAsyncFunction<    {
+    success: boolean;
+    }, Error, string, unknown>;
+    triggerAlert: UseMutateAsyncFunction<    {
+    accepted: boolean;
+    runId?: string;
+    }, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    isTriggering: boolean;
+    data: {
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    };
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: true;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<    {
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+    }, Error>>;
+    fetchStatus: FetchStatus;
+    promise: Promise<{
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    }>;
+} | {
+    alerts: Alert[];
+    createAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, CreateAlertRequest, unknown>;
+    updateAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, {
+    id: string;
+    payload: UpdateAlertRequest;
+    }, unknown>;
+    deleteAlert: UseMutateAsyncFunction<    {
+    success: boolean;
+    }, Error, string, unknown>;
+    triggerAlert: UseMutateAsyncFunction<    {
+    accepted: boolean;
+    runId?: string;
+    }, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    isTriggering: boolean;
+    data: {
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    };
+    error: null;
+    isError: false;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: false;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<    {
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+    }, Error>>;
+    fetchStatus: FetchStatus;
+    promise: Promise<{
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    }>;
+} | {
+    alerts: Alert[];
+    createAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, CreateAlertRequest, unknown>;
+    updateAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, {
+    id: string;
+    payload: UpdateAlertRequest;
+    }, unknown>;
+    deleteAlert: UseMutateAsyncFunction<    {
+    success: boolean;
+    }, Error, string, unknown>;
+    triggerAlert: UseMutateAsyncFunction<    {
+    accepted: boolean;
+    runId?: string;
+    }, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    isTriggering: boolean;
+    data: undefined;
+    error: Error;
+    isError: true;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: true;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "error";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<    {
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+    }, Error>>;
+    fetchStatus: FetchStatus;
+    promise: Promise<{
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    }>;
+} | {
+    alerts: Alert[];
+    createAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, CreateAlertRequest, unknown>;
+    updateAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, {
+    id: string;
+    payload: UpdateAlertRequest;
+    }, unknown>;
+    deleteAlert: UseMutateAsyncFunction<    {
+    success: boolean;
+    }, Error, string, unknown>;
+    triggerAlert: UseMutateAsyncFunction<    {
+    accepted: boolean;
+    runId?: string;
+    }, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    isTriggering: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoading: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<    {
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+    }, Error>>;
+    fetchStatus: FetchStatus;
+    promise: Promise<{
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    }>;
+} | {
+    alerts: Alert[];
+    createAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, CreateAlertRequest, unknown>;
+    updateAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, {
+    id: string;
+    payload: UpdateAlertRequest;
+    }, unknown>;
+    deleteAlert: UseMutateAsyncFunction<    {
+    success: boolean;
+    }, Error, string, unknown>;
+    triggerAlert: UseMutateAsyncFunction<    {
+    accepted: boolean;
+    runId?: string;
+    }, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    isTriggering: boolean;
+    data: undefined;
+    error: null;
+    isError: false;
+    isPending: true;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: false;
+    isPlaceholderData: false;
+    status: "pending";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isLoading: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<    {
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+    }, Error>>;
+    fetchStatus: FetchStatus;
+    promise: Promise<{
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    }>;
+} | {
+    alerts: Alert[];
+    createAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, CreateAlertRequest, unknown>;
+    updateAlert: UseMutateAsyncFunction<    {
+    alert: Alert;
+    }, Error, {
+    id: string;
+    payload: UpdateAlertRequest;
+    }, unknown>;
+    deleteAlert: UseMutateAsyncFunction<    {
+    success: boolean;
+    }, Error, string, unknown>;
+    triggerAlert: UseMutateAsyncFunction<    {
+    accepted: boolean;
+    runId?: string;
+    }, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+    isTriggering: boolean;
+    data: {
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    };
+    isError: false;
+    error: null;
+    isPending: false;
+    isLoading: false;
+    isLoadingError: false;
+    isRefetchError: false;
+    isSuccess: true;
+    isPlaceholderData: true;
+    status: "success";
+    dataUpdatedAt: number;
+    errorUpdatedAt: number;
+    failureCount: number;
+    failureReason: Error | null;
+    errorUpdateCount: number;
+    isFetched: boolean;
+    isFetchedAfterMount: boolean;
+    isFetching: boolean;
+    isInitialLoading: boolean;
+    isPaused: boolean;
+    isRefetching: boolean;
+    isStale: boolean;
+    isEnabled: boolean;
+    refetch: (options?: RefetchOptions) => Promise<QueryObserverResult<    {
+    alerts: Alert[];
+    nextCursor: string | null;
+    total: number;
+    }, Error>>;
+    fetchStatus: FetchStatus;
+    promise: Promise<{
+        alerts: Alert[];
+        nextCursor: string | null;
+        total: number;
+    }>;
+};
+
+export declare function useAlertsBootstrap(): UseQueryResult<    {
+alerts: Alert[];
+nextCursor: null;
+total: number;
+}, Error>;
+
+export declare const useAlertsById: () => Record<string, Alert>;
+
+export declare const useAlertsForCard: (cardId: string) => Alert[];
+
+export declare function useAlertState(alertId: string | undefined): UseQueryResult<    {
+state: AlertState;
+}, Error>;
+
+export declare const useAlertStore: UseBoundStore<Omit<StoreApi<AlertStore>, "setState"> & {
+setState(nextStateOrUpdater: AlertStore | Partial<AlertStore> | ((state: WritableDraft<AlertStore>) => void), shouldReplace?: false): void;
+setState(nextStateOrUpdater: AlertStore | ((state: WritableDraft<AlertStore>) => void), shouldReplace: true): void;
+}>;
+
 export declare function useCard(cardId: string): {
     data: any;
     card: TCard;
@@ -3673,6 +4492,8 @@ export declare function useCard(cardId: string): {
     comparisonMetadata: ComparisonMetadataMap | undefined;
 };
 
+export declare const useCardAlertMap: () => Map<string, string[]>;
+
 export declare function useCardSummary(card: TCard, options?: UseCardSummaryOptions): {
     data: SummaryResponse | undefined;
     isLoading: boolean;
@@ -3928,6 +4749,8 @@ export declare interface UserPreference {
     updatedAt: string;
 }
 
+export declare const useSelectedAlertId: () => string | null;
+
 export declare function useTextFilterHook(filterId: string): {
     isLoading: boolean;
     isFetching: boolean;