@insforge/dashboard 0.0.0-dev.1

package/dist/features/functions/pages/SecretsPage.d.ts

@@ -0,0 +1 @@
+export default function SecretsPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/functions/services/function.service.d.ts

@@ -0,0 +1,8 @@
+import { FunctionSchema, ListFunctionsResponse, UpdateFunctionRequest, FunctionResponse } from '@insforge/shared-schemas';
+export declare class FunctionService {
+    listFunctions(): Promise<ListFunctionsResponse>;
+    getFunctionBySlug(slug: string): Promise<FunctionSchema>;
+    updateFunction(slug: string, updates: UpdateFunctionRequest): Promise<FunctionResponse>;
+    deleteFunction(slug: string): Promise<void>;
+}
+export declare const functionService: FunctionService;

package/dist/features/functions/services/schedule.service.d.ts

@@ -0,0 +1,10 @@
+import type { ScheduleSchema, ListExecutionLogsResponse, CreateScheduleRequest, CreateScheduleResponse, UpdateScheduleRequest, UpdateScheduleResponse, DeleteScheduleResponse } from '@insforge/shared-schemas';
+export declare class ScheduleService {
+    listSchedules(): Promise<ScheduleSchema[]>;
+    getSchedule(id: string): Promise<ScheduleSchema | null>;
+    createSchedule(payload: CreateScheduleRequest): Promise<CreateScheduleResponse>;
+    updateSchedule(scheduleId: string, payload: UpdateScheduleRequest): Promise<UpdateScheduleResponse>;
+    deleteSchedule(scheduleId: string): Promise<DeleteScheduleResponse>;
+    listExecutionLogs(scheduleId: string, limit?: number, offset?: number): Promise<ListExecutionLogsResponse>;
+}
+export declare const scheduleService: ScheduleService;

package/dist/features/functions/services/secret.service.d.ts

@@ -0,0 +1,8 @@
+import { SecretSchema, CreateSecretRequest, CreateSecretResponse, DeleteSecretResponse, GetSecretValueResponse } from '@insforge/shared-schemas';
+export declare class SecretService {
+    listSecrets(): Promise<SecretSchema[]>;
+    createSecret(input: CreateSecretRequest): Promise<CreateSecretResponse>;
+    deleteSecret(key: string): Promise<DeleteSecretResponse>;
+    getSecretValue(key: string): Promise<GetSecretValueResponse>;
+}
+export declare const secretService: SecretService;

package/dist/features/functions/types.d.ts

@@ -0,0 +1,2 @@
+import type { CreateScheduleRequest } from '@insforge/shared-schemas';
+export type ScheduleFormSchema = CreateScheduleRequest;

package/dist/features/login/pages/CloudLoginPage.d.ts

@@ -0,0 +1 @@
+export default function CloudLoginPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/login/pages/LoginPage.d.ts

@@ -0,0 +1 @@
+export default function LoginPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/login/services/login.service.d.ts

@@ -0,0 +1,16 @@
+import type { UserSchema } from '@insforge/shared-schemas';
+interface LoginResult {
+    user: UserSchema;
+    accessToken: string;
+    csrfToken?: string;
+}
+export declare class LoginService {
+    loginWithPassword(email: string, password: string): Promise<LoginResult>;
+    loginWithAuthorizationCode(code: string): Promise<LoginResult>;
+    logout(): Promise<void>;
+    getCurrentUser(): Promise<UserSchema | null>;
+    refreshAccessToken(): Promise<boolean>;
+    setAuthErrorHandler(handler?: () => void): void;
+}
+export declare const loginService: LoginService;
+export {};

package/dist/features/login/services/partnership.service.d.ts

@@ -0,0 +1,18 @@
+export interface PartnershipConfig {
+    partner_sites: string[];
+}
+export declare class PartnershipService {
+    private configCache;
+    private fetchPromise;
+    private readonly CONFIG_URL;
+    /**
+     * Fetches the partnership configuration from S3
+     * Uses caching to avoid repeated fetches
+     */
+    fetchConfig(): Promise<PartnershipConfig | null>;
+    /**
+     * Clears the cached configuration (useful for testing or forcing refresh)
+     */
+    clearCache(): void;
+}
+export declare const partnershipService: PartnershipService;

package/dist/features/logs/components/BuildLogsView.d.ts

@@ -0,0 +1,5 @@
+interface BuildLogsViewProps {
+    className?: string;
+}
+export declare function BuildLogsView({ className }: BuildLogsViewProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/logs/components/FunctionLogsTabs.d.ts

@@ -0,0 +1,12 @@
+export type FunctionLogType = 'runtime' | 'build';
+export interface FunctionLogTab {
+    id: FunctionLogType;
+    label: string;
+}
+interface FunctionLogsTabsProps {
+    value: FunctionLogType;
+    onChange: (value: FunctionLogType) => void;
+    className?: string;
+}
+export declare function FunctionLogsTabs({ value, onChange, className }: FunctionLogsTabsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/logs/components/LogDetailPanel.d.ts

@@ -0,0 +1,7 @@
+import type { LogSchema } from '@insforge/shared-schemas';
+interface LogDetailPanelProps {
+    log: LogSchema | null;
+    onClose: () => void;
+}
+export declare function LogDetailPanel({ log, onClose }: LogDetailPanelProps): import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/features/logs/components/LogsDataGrid.d.ts

@@ -0,0 +1,21 @@
+import { type DataGridProps, type RenderCellProps, type RenderHeaderCellProps, type DataGridColumn, type DataGridRowType } from '../../../components/datagrid';
+export interface LogsColumnDef {
+    key: string;
+    name: string;
+    width?: string;
+    minWidth?: number;
+    maxWidth?: number;
+    sortable?: boolean;
+    renderCell?: (props: RenderCellProps<DataGridRowType>) => React.ReactNode;
+    renderHeaderCell?: (props: RenderHeaderCellProps<DataGridRowType>) => React.ReactNode;
+}
+export declare function createLogsColumns(columnDefs: LogsColumnDef[]): DataGridColumn<DataGridRowType>[];
+export interface LogsDataGridProps<T = Record<string, unknown>> extends Omit<DataGridProps<DataGridRowType>, 'columns' | 'data'> {
+    columnDefs: LogsColumnDef[];
+    data: T[];
+    noPadding?: boolean;
+    selectedRowId?: string | null;
+    onRowClick?: (row: T) => void;
+    rightPanel?: React.ReactNode;
+}
+export declare function LogsDataGrid<T = Record<string, unknown>>({ columnDefs, data, noPadding, selectedRowId, onRowClick, rightPanel, ...restProps }: LogsDataGridProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/components/LogsLayout.d.ts

@@ -0,0 +1 @@
+export default function LogsLayout(): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/components/LogsSidebar.d.ts

@@ -0,0 +1 @@
+export declare function LogsSidebar(): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/components/SeverityBadge.d.ts

@@ -0,0 +1,6 @@
+import { type SeverityType } from '../helpers';
+interface SeverityBadgeProps {
+    severity: SeverityType;
+}
+export declare function SeverityBadge({ severity }: SeverityBadgeProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/logs/components/SeverityFilterDropdown.d.ts

@@ -0,0 +1,6 @@
+interface SeverityFilterDropdownProps {
+    value: string[];
+    onChange: (value: string[]) => void;
+}
+export declare function SeverityFilterDropdown({ value, onChange }: SeverityFilterDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/logs/components/index.d.ts

@@ -0,0 +1,7 @@
+export { LogsDataGrid, createLogsColumns, type LogsColumnDef } from './LogsDataGrid';
+export { SeverityBadge } from './SeverityBadge';
+export { SeverityFilterDropdown } from './SeverityFilterDropdown';
+export { LogDetailPanel } from './LogDetailPanel';
+export { FunctionLogsTabs, type FunctionLogType } from './FunctionLogsTabs';
+export { BuildLogsView } from './BuildLogsView';
+export { LogsSidebar } from './LogsSidebar';

package/dist/features/logs/helpers.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Severity options for log filtering
+ */
+export declare const SEVERITY_OPTIONS: readonly [{
+    readonly value: "error";
+    readonly label: "Error";
+    readonly color: "text-red-500";
+}, {
+    readonly value: "warning";
+    readonly label: "Warning";
+    readonly color: "text-yellow-500";
+}, {
+    readonly value: "informational";
+    readonly label: "Info";
+    readonly color: "text-gray-500";
+}];
+/**
+ * Severity configuration for badges
+ */
+export declare const SEVERITY_CONFIG: {
+    readonly error: {
+        readonly color: "#EF4444";
+        readonly label: "Error";
+    };
+    readonly warning: {
+        readonly color: "#FCD34D";
+        readonly label: "Warning";
+    };
+    readonly informational: {
+        readonly color: "#A3A3A3";
+        readonly label: "Info";
+    };
+};
+export type SeverityType = keyof typeof SEVERITY_CONFIG;
+/**
+ * Default page size for logs pagination
+ */
+export declare const LOGS_PAGE_SIZE = 50;

package/dist/features/logs/hooks/useAuditLogs.d.ts

@@ -0,0 +1,38 @@
+import { GetAuditLogsRequest } from '@insforge/shared-schemas';
+export declare const useAuditLogs: (filters?: Partial<GetAuditLogsRequest>) => import("@tanstack/react-query").UseQueryResult<{
+    data: {
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        actor: string;
+        action: string;
+        module: string;
+        details: Record<string, unknown> | null;
+        ipAddress: string | null;
+    }[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+    };
+}, Error>;
+export declare const useAuditLogStats: (days?: number) => import("@tanstack/react-query").UseQueryResult<{
+    totalLogs: number;
+    uniqueActors: number;
+    uniqueModules: number;
+    actionsByModule: Record<string, number>;
+    recentActivity: {
+        id: string;
+        createdAt: string;
+        updatedAt: string;
+        actor: string;
+        action: string;
+        module: string;
+        details: Record<string, unknown> | null;
+        ipAddress: string | null;
+    }[];
+}, Error>;
+export declare const useClearAuditLogs: () => import("@tanstack/react-query").UseMutationResult<{
+    message: string;
+    deleted: number;
+}, Error, number | undefined, unknown>;

package/dist/features/logs/hooks/useLogSources.d.ts

@@ -0,0 +1,41 @@
+import type { FeatureSidebarListItem } from '../../../components';
+import type { LogSourceSchema } from '@insforge/shared-schemas';
+export declare function useLogSources(): {
+    sources: {
+        id: string;
+        name: string;
+        token: string;
+    }[];
+    sourceNames: string[];
+    sourcesCount: number;
+    selectedSource: string | null;
+    stats: {
+        count: number;
+        source: string;
+        lastActivity: string;
+    }[];
+    menuItems: FeatureSidebarListItem[];
+    isLoading: boolean;
+    isLoadingStats: boolean;
+    error: Error | null;
+    statsError: Error | null;
+    selectSource: (sourceName: string) => void;
+    clearSelection: () => void;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        id: string;
+        name: string;
+        token: string;
+    }[], Error>>;
+    refetchStats: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        count: number;
+        source: string;
+        lastActivity: string;
+    }[], Error>>;
+    refreshAll: () => Promise<void>;
+    getSourceByName: (name: string) => LogSourceSchema | undefined;
+    getStatsForSource: (sourceName: string) => {
+        count: number;
+        source: string;
+        lastActivity: string;
+    } | undefined;
+};

package/dist/features/logs/hooks/useLogs.d.ts

@@ -0,0 +1,51 @@
+import type { LogSchema } from '@insforge/shared-schemas';
+import { SeverityType } from '../helpers';
+export declare function useLogs(source: string, pageSize?: number): {
+    logs: {
+        id: string;
+        timestamp: string;
+        eventMessage: string;
+        body: Record<string, unknown>;
+        source?: string | undefined;
+    }[];
+    allLogs: {
+        id: string;
+        timestamp: string;
+        eventMessage: string;
+        body: Record<string, unknown>;
+        source?: string | undefined;
+    }[];
+    filteredLogs: {
+        id: string;
+        timestamp: string;
+        eventMessage: string;
+        body: Record<string, unknown>;
+        source?: string | undefined;
+    }[];
+    totalLogs: number;
+    searchQuery: string;
+    setSearchQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    severityFilter: string[];
+    setSeverityFilter: import("react").Dispatch<import("react").SetStateAction<string[]>>;
+    currentPage: number;
+    setCurrentPage: import("react").Dispatch<import("react").SetStateAction<number>>;
+    totalPages: number;
+    startIndex: number;
+    endIndex: number;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    hasMore: boolean;
+    error: Error | null;
+    loadMoreLogs: () => Promise<void>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        logs: {
+            id: string;
+            timestamp: string;
+            eventMessage: string;
+            body: Record<string, unknown>;
+            source?: string | undefined;
+        }[];
+        total: number;
+    }, Error>>;
+    getSeverity: (log: LogSchema) => SeverityType;
+};

package/dist/features/logs/hooks/useMcpUsage.d.ts

@@ -0,0 +1,35 @@
+import { McpUsageRecord } from '../services/usage.service';
+interface UseMcpUsageOptions {
+    successFilter?: boolean | null;
+    limit?: number;
+    pageSize?: number;
+}
+/**
+ * Hook to manage MCP usage data
+ *
+ * Features:
+ * - Fetches MCP logs from backend
+ * - Provides helper functions for data access
+ * - Handles initial parent window notification for onboarding (if in iframe)
+ * - Supports search and pagination
+ *
+ */
+export declare function useMcpUsage(options?: UseMcpUsageOptions): {
+    records: McpUsageRecord[];
+    allRecords: McpUsageRecord[];
+    filteredRecords: McpUsageRecord[];
+    hasCompletedOnboarding: boolean;
+    latestRecord: McpUsageRecord;
+    recordsCount: number;
+    filteredRecordsCount: number;
+    searchQuery: string;
+    setSearchQuery: import("react").Dispatch<import("react").SetStateAction<string>>;
+    currentPage: number;
+    setCurrentPage: import("react").Dispatch<import("react").SetStateAction<number>>;
+    totalPages: number;
+    pageSize: number;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<McpUsageRecord[], Error>>;
+};
+export {};

package/dist/features/logs/pages/AuditsPage.d.ts

@@ -0,0 +1 @@
+export default function AuditsPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/pages/FunctionLogsPage.d.ts

@@ -0,0 +1 @@
+export default function FunctionLogsPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/pages/LogsPage.d.ts

@@ -0,0 +1 @@
+export default function LogsPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/pages/MCPLogsPage.d.ts

@@ -0,0 +1 @@
+export default function MCPLogsPage(): import("react/jsx-runtime").JSX.Element;

package/dist/features/logs/services/audit.service.d.ts

@@ -0,0 +1,7 @@
+import { GetAuditLogsResponse, ClearAuditLogsResponse, GetAuditLogsRequest, GetAuditLogStatsResponse } from '@insforge/shared-schemas';
+export declare class AuditService {
+    getAuditLogs({ limit, offset, ...filters }: GetAuditLogsRequest): Promise<GetAuditLogsResponse>;
+    getAuditLogStats(days?: number): Promise<GetAuditLogStatsResponse>;
+    clearAuditLogs(daysToKeep?: number): Promise<ClearAuditLogsResponse>;
+}
+export declare const auditService: AuditService;

package/dist/features/logs/services/log.service.d.ts

@@ -0,0 +1,22 @@
+import type { LogSourceSchema, LogSchema, GetLogsResponse, LogStatsSchema } from '@insforge/shared-schemas';
+export interface BuildLogEntry {
+    level: string;
+    message: string;
+}
+export interface GetBuildLogsResponse {
+    deploymentId: string;
+    status: 'pending' | 'success' | 'failed';
+    logs: BuildLogEntry[];
+    createdAt: string;
+}
+export declare class LogService {
+    getLogSources(): Promise<LogSourceSchema[]>;
+    getLogSourceStats(): Promise<LogStatsSchema[]>;
+    getLogsBySource(sourceName: string, limit?: number, beforeTimestamp?: string): Promise<GetLogsResponse>;
+    searchLogs(query: string, sourceName?: string, limit?: number, offset?: number): Promise<{
+        records: LogSchema[];
+        total: number;
+    }>;
+    getFunctionBuildLogs(deploymentId?: string): Promise<GetBuildLogsResponse | null>;
+}
+export declare const logService: LogService;

package/dist/features/logs/services/usage.service.d.ts

@@ -0,0 +1,16 @@
+export interface McpUsageRecord {
+    id?: string;
+    tool_name: string;
+    success: boolean;
+    created_at: string;
+}
+export interface McpUsageResponse {
+    records: McpUsageRecord[];
+}
+export declare class UsageService {
+    /**
+     * Get MCP usage records
+     */
+    getMcpUsage(success?: boolean | null, limit?: number): Promise<McpUsageRecord[]>;
+}
+export declare const usageService: UsageService;

package/dist/features/realtime/components/ChannelFormDialog.d.ts

@@ -0,0 +1,13 @@
+import { type CreateChannelRequest, type UpdateChannelRequest } from '@insforge/shared-schemas';
+import type { RealtimeChannel } from '../services/realtime.service';
+interface ChannelFormDialogProps {
+    mode: 'create' | 'edit';
+    channel?: RealtimeChannel | null;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    onSave?: (id: string, data: UpdateChannelRequest) => void;
+    onCreate?: (data: CreateChannelRequest) => void;
+    isUpdating?: boolean;
+}
+export declare function ChannelFormDialog({ mode, channel, open, onOpenChange, onSave, onCreate, isUpdating, }: ChannelFormDialogProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/realtime/components/ChannelRow.d.ts

@@ -0,0 +1,12 @@
+import type { RealtimeChannel } from '../services/realtime.service';
+interface ChannelRowProps {
+    channel: RealtimeChannel;
+    onClick: () => void;
+    onToggleEnabled: (enabled: boolean) => void;
+    onDelete: () => void;
+    isUpdating?: boolean;
+    isDeleting?: boolean;
+    className?: string;
+}
+export declare function ChannelRow({ channel, onClick, onToggleEnabled, onDelete, isUpdating, isDeleting, className, }: ChannelRowProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/realtime/components/MessageRow.d.ts

@@ -0,0 +1,7 @@
+import type { RealtimeMessage } from '../services/realtime.service';
+interface MessageRowProps {
+    message: RealtimeMessage;
+    className?: string;
+}
+export declare function MessageRow({ message, className }: MessageRowProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/realtime/components/RealtimeEmptyState.d.ts

@@ -0,0 +1,6 @@
+interface RealtimeEmptyStateProps {
+    type: 'channels' | 'messages';
+    onCreateChannel?: () => void;
+}
+export default function RealtimeEmptyState({ type, onCreateChannel }: RealtimeEmptyStateProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/features/realtime/components/RealtimeLayout.d.ts

@@ -0,0 +1 @@
+export default function RealtimeLayout(): import("react/jsx-runtime").JSX.Element;

package/dist/features/realtime/components/RealtimeSettingsMenuDialog.d.ts

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

package/dist/features/realtime/components/RealtimeSidebar.d.ts

@@ -0,0 +1 @@
+export declare function RealtimeSidebar(): import("react/jsx-runtime").JSX.Element;

package/dist/features/realtime/hooks/useRealtimeChannels.d.ts

@@ -0,0 +1,66 @@
+import { type RealtimeChannel } from '../services/realtime.service';
+import type { UpdateChannelRequest } from '@insforge/shared-schemas';
+export declare function useRealtimeChannels(): {
+    channels: {
+        id: string;
+        createdAt: string;
+        description: string | null;
+        enabled: boolean;
+        updatedAt: string;
+        pattern: string;
+        webhookUrls: string[] | null;
+    }[];
+    channelsCount: number;
+    selectedChannel: {
+        id: string;
+        createdAt: string;
+        description: string | null;
+        enabled: boolean;
+        updatedAt: string;
+        pattern: string;
+        webhookUrls: string[] | null;
+    } | null;
+    isLoadingChannels: boolean;
+    channelsError: Error | null;
+    refetchChannels: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        id: string;
+        createdAt: string;
+        description: string | null;
+        enabled: boolean;
+        updatedAt: string;
+        pattern: string;
+        webhookUrls: string[] | null;
+    }[], Error>>;
+    selectChannel: (channel: RealtimeChannel | null) => void;
+    clearSelection: () => void;
+    createChannel: import("@tanstack/react-query").UseMutateFunction<{
+        id: string;
+        createdAt: string;
+        description: string | null;
+        enabled: boolean;
+        updatedAt: string;
+        pattern: string;
+        webhookUrls: string[] | null;
+    }, Error, {
+        enabled: boolean;
+        pattern: string;
+        description?: string | undefined;
+        webhookUrls?: string[] | undefined;
+    }, unknown>;
+    updateChannel: import("@tanstack/react-query").UseMutateFunction<{
+        id: string;
+        createdAt: string;
+        description: string | null;
+        enabled: boolean;
+        updatedAt: string;
+        pattern: string;
+        webhookUrls: string[] | null;
+    }, Error, {
+        id: string;
+        data: UpdateChannelRequest;
+    }, unknown>;
+    deleteChannel: import("@tanstack/react-query").UseMutateFunction<void, Error, string, unknown>;
+    isCreating: boolean;
+    isUpdating: boolean;
+    isDeleting: boolean;
+};

package/dist/features/realtime/hooks/useRealtimeConfig.d.ts

@@ -0,0 +1,14 @@
+export declare function useRealtimeConfig(): {
+    config: {
+        retentionDays: number | null;
+    } | undefined;
+    isLoading: boolean;
+    isUpdating: boolean;
+    error: Error | null;
+    updateConfig: import("@tanstack/react-query").UseMutateAsyncFunction<void, Error, {
+        retentionDays: number | null;
+    }, unknown>;
+    refetch: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        retentionDays: number | null;
+    }, Error>>;
+};

package/dist/features/realtime/hooks/useRealtimeMessages.d.ts

@@ -0,0 +1,64 @@
+import type { ListMessagesRequest } from '@insforge/shared-schemas';
+export declare function useRealtimeMessages(): {
+    messages: {
+        id: string;
+        createdAt: string;
+        eventName: string;
+        channelId: string | null;
+        channelName: string;
+        payload: Record<string, unknown>;
+        senderType: "user" | "system";
+        senderId: string | null;
+        wsAudienceCount: number;
+        whAudienceCount: number;
+        whDeliveredCount: number;
+    }[];
+    messagesCount: number;
+    messagesParams: {
+        limit: number;
+        offset: number;
+        eventName?: string | undefined;
+        channelId?: string | undefined;
+    };
+    isLoadingMessages: boolean;
+    messagesError: Error | null;
+    stats: {
+        retentionDays: number | null;
+        totalMessages: number;
+        whDeliveryRate: number;
+        topEvents: {
+            count: number;
+            eventName: string;
+        }[];
+    } | undefined;
+    isLoadingStats: boolean;
+    messagesPageSize: number;
+    messagesCurrentPage: number;
+    messagesTotalCount: number;
+    messagesTotalPages: number;
+    setMessagesPage: (page: number) => void;
+    filterMessages: (params: Partial<ListMessagesRequest>) => void;
+    refetchMessages: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        id: string;
+        createdAt: string;
+        eventName: string;
+        channelId: string | null;
+        channelName: string;
+        payload: Record<string, unknown>;
+        senderType: "user" | "system";
+        senderId: string | null;
+        wsAudienceCount: number;
+        whAudienceCount: number;
+        whDeliveredCount: number;
+    }[], Error>>;
+    refetchStats: (options?: import("@tanstack/query-core").RefetchOptions) => Promise<import("@tanstack/query-core").QueryObserverResult<{
+        retentionDays: number | null;
+        totalMessages: number;
+        whDeliveryRate: number;
+        topEvents: {
+            count: number;
+            eventName: string;
+        }[];
+    }, Error>>;
+    refetch: () => void;
+};