@superatomai/sdk-node 0.0.1

package/dist/index.d.mts

@@ -0,0 +1,1239 @@
+import { z } from 'zod';
+
+declare const DSLRendererPropsSchema$1: z.ZodObject<{
+    dsl: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        states: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        methods: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            fn: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }>>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            fn: z.ZodString;
+            deps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            fn: string;
+            deps?: string[] | undefined;
+        }, {
+            fn: string;
+            deps?: string[] | undefined;
+        }>, "many">>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        render: z.ZodType<any, z.ZodTypeDef, any>;
+        query: z.ZodOptional<z.ZodObject<{
+            graphql: z.ZodOptional<z.ZodString>;
+            sql: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            key: z.ZodOptional<z.ZodString>;
+            refetchPolicy: z.ZodOptional<z.ZodEnum<["cache-first", "network-only", "cache-and-network"]>>;
+            dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        }, {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    }, {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    }>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    dsl: {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    };
+    data?: Record<string, any> | undefined;
+    context?: Record<string, any> | undefined;
+}, {
+    dsl: {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    };
+    data?: Record<string, any> | undefined;
+    context?: Record<string, any> | undefined;
+}>;
+type DSLRendererProps$1 = z.infer<typeof DSLRendererPropsSchema$1>;
+
+declare const DSLRendererPropsSchema: z.ZodObject<{
+    dsl: z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        props: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        states: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        methods: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            fn: z.ZodString;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, "strip", z.ZodTypeAny, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }>>>;
+        effects: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            fn: z.ZodString;
+            deps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            fn: string;
+            deps?: string[] | undefined;
+        }, {
+            fn: string;
+            deps?: string[] | undefined;
+        }>, "many">>;
+        data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        render: z.ZodType<any, z.ZodTypeDef, any>;
+        query: z.ZodOptional<z.ZodObject<{
+            graphql: z.ZodOptional<z.ZodString>;
+            sql: z.ZodOptional<z.ZodString>;
+            variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+            key: z.ZodOptional<z.ZodString>;
+            refetchPolicy: z.ZodOptional<z.ZodEnum<["cache-first", "network-only", "cache-and-network"]>>;
+            dependencies: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        }, {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    }, {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    }>;
+    data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    dsl: {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    };
+    data?: Record<string, any> | undefined;
+    context?: Record<string, any> | undefined;
+}, {
+    dsl: {
+        id: string;
+        name?: string | undefined;
+        query?: {
+            params?: Record<string, any> | undefined;
+            key?: string | undefined;
+            graphql?: string | undefined;
+            sql?: string | undefined;
+            variables?: Record<string, any> | undefined;
+            refetchPolicy?: "cache-first" | "network-only" | "cache-and-network" | undefined;
+            dependencies?: string[] | undefined;
+        } | undefined;
+        props?: Record<string, any> | undefined;
+        states?: Record<string, any> | undefined;
+        methods?: Record<string, {
+            fn: string;
+            params?: Record<string, any> | undefined;
+        }> | undefined;
+        effects?: {
+            fn: string;
+            deps?: string[] | undefined;
+        }[] | undefined;
+        data?: Record<string, any> | undefined;
+        render?: any;
+    };
+    data?: Record<string, any> | undefined;
+    context?: Record<string, any> | undefined;
+}>;
+type DSLRendererProps = z.infer<typeof DSLRendererPropsSchema>;
+
+declare const MessageSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    from: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }>;
+    to: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }>>;
+    payload: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    from: {
+        id?: string | undefined;
+        type?: string | undefined;
+    };
+    id?: string | undefined;
+    to?: {
+        id?: string | undefined;
+        type?: string | undefined;
+    } | undefined;
+    payload?: unknown;
+}, {
+    type: string;
+    from: {
+        id?: string | undefined;
+        type?: string | undefined;
+    };
+    id?: string | undefined;
+    to?: {
+        id?: string | undefined;
+        type?: string | undefined;
+    } | undefined;
+    payload?: unknown;
+}>;
+type Message = z.infer<typeof MessageSchema>;
+declare const IncomingMessageSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
+    type: z.ZodString;
+    from: z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }>;
+    to: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        type: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }, {
+        id?: string | undefined;
+        type?: string | undefined;
+    }>>;
+    payload: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    from: {
+        id?: string | undefined;
+        type?: string | undefined;
+    };
+    id?: string | undefined;
+    to?: {
+        id?: string | undefined;
+        type?: string | undefined;
+    } | undefined;
+    payload?: unknown;
+}, {
+    type: string;
+    from: {
+        id?: string | undefined;
+        type?: string | undefined;
+    };
+    id?: string | undefined;
+    to?: {
+        id?: string | undefined;
+        type?: string | undefined;
+    } | undefined;
+    payload?: unknown;
+}>;
+type IncomingMessage = z.infer<typeof IncomingMessageSchema>;
+type CollectionOperation = 'getMany' | 'getOne' | 'query' | 'mutation' | 'updateOne' | 'deleteOne' | 'createOne';
+type CollectionHandler<TParams = any, TResult = any> = (params: TParams) => Promise<TResult> | TResult;
+type LLMProvider = 'anthropic' | 'groq';
+interface SuperatomSDKConfig {
+    url?: string;
+    apiKey: string;
+    projectId: string;
+    userId?: string;
+    type?: string;
+    bundleDir?: string;
+    ANTHROPIC_API_KEY?: string;
+    GROQ_API_KEY?: string;
+    LLM_PROVIDERS?: LLMProvider[];
+}
+
+interface User {
+    username: string;
+    password: string;
+    wsIds: string[];
+}
+interface UsersData {
+    users: User[];
+}
+/**
+ * UserManager class to handle CRUD operations on users with file persistence
+ * and in-memory caching. Changes are synced to file periodically.
+ */
+declare class UserManager {
+    private users;
+    private filePath;
+    private hasChanged;
+    private syncInterval;
+    private syncIntervalMs;
+    private isInitialized;
+    /**
+     * Initialize UserManager with file path and sync interval
+     * @param projectId - Project ID to use in file path (default: 'snowflake-dataset')
+     * @param syncIntervalMs - Interval in milliseconds to sync changes to file (default: 5000ms)
+     */
+    constructor(projectId?: string, syncIntervalMs?: number);
+    /**
+     * Initialize the UserManager by loading users from file and starting sync interval
+     */
+    init(): Promise<void>;
+    /**
+     * Load users from the JSON file into memory
+     */
+    private loadUsersFromFile;
+    /**
+     * Save users from memory to the JSON file
+     */
+    private saveUsersToFile;
+    /**
+     * Start the periodic sync interval
+     */
+    private startSyncInterval;
+    /**
+     * Stop the periodic sync interval
+     */
+    stopSyncInterval(): void;
+    /**
+     * Force sync users to file immediately
+     */
+    forceSync(): Promise<void>;
+    /**
+     * Create a new user
+     * @param user - User object to create
+     * @returns The created user
+     */
+    createUser(user: User): User;
+    /**
+     * Read a user by username
+     * @param username - Username to retrieve
+     * @returns The user if found, undefined otherwise
+     */
+    getUser(username: string): User | undefined;
+    /**
+     * Read all users
+     * @returns Array of all users
+     */
+    getAllUsers(): User[];
+    /**
+     * Find users by a predicate function
+     * @param predicate - Function to filter users
+     * @returns Array of matching users
+     */
+    findUsers(predicate: (user: User) => boolean): User[];
+    /**
+     * Update an existing user by username
+     * @param username - Username of user to update
+     * @param updates - Partial user object with fields to update
+     * @returns The updated user
+     */
+    updateUser(username: string, updates: Partial<User>): User;
+    /**
+     * Delete a user by username
+     * @param username - Username of user to delete
+     * @returns true if user was deleted, false if not found
+     */
+    deleteUser(username: string): boolean;
+    /**
+     * Delete all users
+     */
+    deleteAllUsers(): void;
+    /**
+     * Get the count of users
+     * @returns Number of users in memory
+     */
+    getUserCount(): number;
+    /**
+     * Check if a user exists
+     * @param username - Username to check
+     * @returns true if user exists, false otherwise
+     */
+    userExists(username: string): boolean;
+    /**
+     * Add a WebSocket ID to a user's wsIds array
+     * @param username - Username to update
+     * @param wsId - WebSocket ID to add
+     * @returns true if successful, false if user not found
+     */
+    addWsId(username: string, wsId: string): boolean;
+    /**
+     * Remove a WebSocket ID from a user's wsIds array
+     * @param username - Username to update
+     * @param wsId - WebSocket ID to remove
+     * @returns true if successful, false if user not found
+     */
+    removeWsId(username: string, wsId: string): boolean;
+    /**
+     * Get the change status
+     * @returns true if there are unsaved changes, false otherwise
+     */
+    hasUnsavedChanges(): boolean;
+    /**
+     * Cleanup resources and stop sync interval
+     */
+    destroy(): Promise<void>;
+}
+
+/**
+ * DashboardManager class to handle CRUD operations on dashboards
+ * All operations read/write directly to files (no in-memory caching)
+ */
+declare class DashboardManager {
+    private dashboardsBasePath;
+    private projectId;
+    /**
+     * Initialize DashboardManager with project ID
+     * @param projectId - Project ID to use in file path
+     */
+    constructor(projectId?: string);
+    /**
+     * Get the file path for a specific dashboard
+     * @param dashboardId - Dashboard ID
+     * @returns Full path to dashboard data.json file
+     */
+    private getDashboardPath;
+    /**
+     * Create a new dashboard
+     * @param dashboardId - Unique dashboard ID
+     * @param dashboard - Dashboard data
+     * @returns Created dashboard with metadata
+     */
+    createDashboard(dashboardId: string, dashboard: DSLRendererProps$1): DSLRendererProps$1;
+    /**
+     * Get a specific dashboard by ID
+     * @param dashboardId - Dashboard ID
+     * @returns Dashboard data or null if not found
+     */
+    getDashboard(dashboardId: string): DSLRendererProps$1 | null;
+    /**
+     * Get all dashboards
+     * @returns Array of dashboard objects with their IDs
+     */
+    getAllDashboards(): Array<{
+        dashboardId: string;
+        dashboard: DSLRendererProps$1;
+    }>;
+    /**
+     * Update an existing dashboard
+     * @param dashboardId - Dashboard ID
+     * @param dashboard - Updated dashboard data
+     * @returns Updated dashboard or null if not found
+     */
+    updateDashboard(dashboardId: string, dashboard: DSLRendererProps$1): DSLRendererProps$1 | null;
+    /**
+     * Delete a dashboard
+     * @param dashboardId - Dashboard ID
+     * @returns True if deleted, false if not found
+     */
+    deleteDashboard(dashboardId: string): boolean;
+    /**
+     * Check if a dashboard exists
+     * @param dashboardId - Dashboard ID
+     * @returns True if dashboard exists, false otherwise
+     */
+    dashboardExists(dashboardId: string): boolean;
+    /**
+     * Get dashboard count
+     * @returns Number of dashboards
+     */
+    getDashboardCount(): number;
+}
+
+/**
+ * ReportManager class to handle CRUD operations on reports
+ * All operations read/write directly to files (no in-memory caching)
+ */
+declare class ReportManager {
+    private reportsBasePath;
+    private projectId;
+    /**
+     * Initialize ReportManager with project ID
+     * @param projectId - Project ID to use in file path
+     */
+    constructor(projectId?: string);
+    /**
+     * Get the file path for a specific report
+     * @param reportId - Report ID
+     * @returns Full path to report data.json file
+     */
+    private getReportPath;
+    /**
+     * Create a new report
+     * @param reportId - Unique report ID
+     * @param report - Report data
+     * @returns Created report with metadata
+     */
+    createReport(reportId: string, report: DSLRendererProps): DSLRendererProps;
+    /**
+     * Get a specific report by ID
+     * @param reportId - Report ID
+     * @returns Report data or null if not found
+     */
+    getReport(reportId: string): DSLRendererProps | null;
+    /**
+     * Get all reports
+     * @returns Array of report objects with their IDs
+     */
+    getAllReports(): Array<{
+        reportId: string;
+        report: DSLRendererProps;
+    }>;
+    /**
+     * Update an existing report
+     * @param reportId - Report ID
+     * @param report - Updated report data
+     * @returns Updated report or null if not found
+     */
+    updateReport(reportId: string, report: DSLRendererProps): DSLRendererProps | null;
+    /**
+     * Delete a report
+     * @param reportId - Report ID
+     * @returns True if deleted, false if not found
+     */
+    deleteReport(reportId: string): boolean;
+    /**
+     * Check if a report exists
+     * @param reportId - Report ID
+     * @returns True if report exists, false otherwise
+     */
+    reportExists(reportId: string): boolean;
+    /**
+     * Get report count
+     * @returns Number of reports
+     */
+    getReportCount(): number;
+}
+
+interface LLMMessages {
+    sys: string;
+    user: string;
+}
+interface LLMOptions {
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    apiKey?: string;
+    partial?: (chunk: string) => void;
+}
+declare class LLM {
+    static text(messages: LLMMessages, options?: LLMOptions): Promise<string>;
+    static stream<T = string>(messages: LLMMessages, options?: LLMOptions, json?: boolean): Promise<T extends string ? string : any>;
+    /**
+     * Parse model string to extract provider and model name
+     * @param modelString - Format: "provider/model-name" or just "model-name"
+     * @returns [provider, modelName]
+     *
+     * @example
+     * "anthropic/claude-sonnet-4-5" → ["anthropic", "claude-sonnet-4-5"]
+     * "groq/gpt-oss-120b" → ["groq", "gpt-oss-120b"]
+     * "claude-sonnet-4-5" → ["anthropic", "claude-sonnet-4-5"] (default)
+     */
+    private static _parseModel;
+    private static _anthropicText;
+    private static _anthropicStream;
+    private static _groqText;
+    private static _groqStream;
+    /**
+     * Parse JSON string, handling markdown code blocks and surrounding text
+     * Enhanced version from anthropic.ts implementation
+     * @param text - Text that may contain JSON wrapped in ```json...``` or with surrounding text
+     * @returns Parsed JSON object
+     */
+    private static _parseJSON;
+}
+
+interface CapturedLog {
+    timestamp: number;
+    level: 'info' | 'error' | 'warn' | 'debug';
+    message: string;
+    type?: 'explanation' | 'query' | 'general';
+    data?: Record<string, any>;
+}
+/**
+ * UILogCollector captures logs during user prompt processing
+ * and sends them to runtime via ui_logs message with uiBlockId as the message id
+ * Logs are sent in real-time for streaming effect in the UI
+ */
+declare class UILogCollector {
+    private logs;
+    private uiBlockId;
+    private clientId;
+    private sendMessage;
+    constructor(clientId: string, sendMessage: (message: Message) => void, uiBlockId?: string);
+    /**
+     * Check if logging is enabled (uiBlockId is provided)
+     */
+    isEnabled(): boolean;
+    /**
+     * Add a log entry with timestamp and immediately send to runtime
+     */
+    private addLog;
+    /**
+     * Send a single log to runtime immediately
+     */
+    private sendLogImmediately;
+    /**
+     * Log info message
+     */
+    info(message: string, type?: 'explanation' | 'query' | 'general', data?: Record<string, any>): void;
+    /**
+     * Log error message
+     */
+    error(message: string, type?: 'explanation' | 'query' | 'general', data?: Record<string, any>): void;
+    /**
+     * Log warning message
+     */
+    warn(message: string, type?: 'explanation' | 'query' | 'general', data?: Record<string, any>): void;
+    /**
+     * Log debug message
+     */
+    debug(message: string, type?: 'explanation' | 'query' | 'general', data?: Record<string, any>): void;
+    /**
+     * Log LLM explanation with typed metadata
+     */
+    logExplanation(message: string, explanation: string, data?: Record<string, any>): void;
+    /**
+     * Log generated query with typed metadata
+     */
+    logQuery(message: string, query: string, data?: Record<string, any>): void;
+    /**
+     * Send all collected logs at once (optional, for final summary)
+     */
+    sendAllLogs(): void;
+    /**
+     * Get all collected logs
+     */
+    getLogs(): CapturedLog[];
+    /**
+     * Clear all logs
+     */
+    clearLogs(): void;
+    /**
+     * Set uiBlockId (in case it's provided later)
+     */
+    setUIBlockId(uiBlockId: string): void;
+}
+
+/**
+ * Represents an action that can be performed on a UIBlock
+ */
+interface Action {
+    id: string;
+    name: string;
+    type: string;
+    [key: string]: any;
+}
+
+/**
+ * UIBlock represents a single user and assistant message block in a thread
+ * Contains user question, component metadata, component data, and available actions
+ */
+declare class UIBlock {
+    private id;
+    private userQuestion;
+    private generatedComponentMetadata;
+    private componentData;
+    private actions;
+    private createdAt;
+    /**
+     * Creates a new UIBlock instance
+     * @param userQuestion - The user's question or input
+     * @param componentData - The component data object
+     * @param generatedComponentMetadata - Optional metadata about the generated component
+     * @param actions - Optional array of available actions
+     * @param id - Optional custom ID, generates UUID if not provided
+     */
+    constructor(userQuestion: string, componentData?: Record<string, any>, generatedComponentMetadata?: Record<string, any>, actions?: Action[], id?: string);
+    /**
+     * Get the UIBlock ID
+     */
+    getId(): string;
+    /**
+     * Get the user question
+     */
+    getUserQuestion(): string;
+    /**
+     * Set or update the user question
+     */
+    setUserQuestion(question: string): void;
+    /**
+     * Get component metadata
+     */
+    getComponentMetadata(): Record<string, any>;
+    /**
+     * Set or update component metadata
+     */
+    setComponentMetadata(metadata: Record<string, any>): void;
+    /**
+     * Get component data
+     */
+    getComponentData(): Record<string, any>;
+    /**
+     * Calculate size of data in bytes
+     */
+    private getDataSizeInBytes;
+    /**
+     * Limit array data to maximum rows
+     */
+    private limitArrayData;
+    /**
+     * Check if data exceeds size limit
+     */
+    private exceedsSizeLimit;
+    /**
+     * Process and limit data before storing
+     */
+    private processDataForStorage;
+    /**
+     * Set or update component data with size and row limits
+     */
+    setComponentData(data: Record<string, any>): void;
+    /**
+     * Get all actions (only if they are resolved, not if fetching)
+     */
+    getActions(): Action[] | null | Promise<Action[]>;
+    /**
+     * Get or fetch actions
+     * If actions don't exist or are a Promise, calls the generateFn and stores the promise
+     * If actions already exist, returns them
+     * @param generateFn - Async function to generate actions
+     * @returns Promise resolving to Action[]
+     */
+    getOrFetchActions(generateFn: () => Promise<Action[]>): Promise<Action[]>;
+    /**
+     * Add a single action (only if actions are resolved)
+     */
+    addAction(action: Action): void;
+    /**
+     * Add multiple actions (only if actions are resolved)
+     */
+    addActions(actions: Action[]): void;
+    /**
+     * Remove an action by ID (only if actions are resolved)
+     */
+    removeAction(actionId: string): boolean;
+    /**
+     * Clear all actions
+     */
+    clearActions(): void;
+    /**
+     * Get creation timestamp
+     */
+    getCreatedAt(): Date;
+    /**
+     * Convert UIBlock to JSON-serializable object
+     */
+    toJSON(): Record<string, any>;
+}
+
+/**
+ * Thread represents a conversation thread containing multiple UIBlocks
+ * Each UIBlock in a thread represents a user question and assistant response pair
+ */
+declare class Thread {
+    private id;
+    private uiblocks;
+    private createdAt;
+    /**
+     * Creates a new Thread instance
+     * @param id - Optional custom ID, generates UUID if not provided
+     */
+    constructor(id?: string);
+    /**
+     * Get the thread ID
+     */
+    getId(): string;
+    /**
+     * Add a UIBlock to the thread
+     */
+    addUIBlock(uiblock: UIBlock): void;
+    /**
+     * Get a UIBlock by ID
+     */
+    getUIBlock(id: string): UIBlock | undefined;
+    /**
+     * Get all UIBlocks in the thread
+     */
+    getUIBlocks(): UIBlock[];
+    /**
+     * Get UIBlocks as a Map
+     */
+    getUIBlocksMap(): Map<string, UIBlock>;
+    /**
+     * Remove a UIBlock by ID
+     */
+    removeUIBlock(id: string): boolean;
+    /**
+     * Check if UIBlock exists
+     */
+    hasUIBlock(id: string): boolean;
+    /**
+     * Get number of UIBlocks in the thread
+     */
+    getUIBlockCount(): number;
+    /**
+     * Clear all UIBlocks from the thread
+     */
+    clear(): void;
+    /**
+     * Get creation timestamp
+     */
+    getCreatedAt(): Date;
+    /**
+     * Get conversation context from recent UIBlocks (excluding current one)
+     * Returns formatted string with previous questions and component summaries
+     * @param limit - Maximum number of previous UIBlocks to include (default: 5)
+     * @param currentUIBlockId - ID of current UIBlock to exclude from context (optional)
+     * @returns Formatted conversation history string
+     */
+    getConversationContext(limit?: number, currentUIBlockId?: string): string;
+    /**
+     * Convert Thread to JSON-serializable object
+     */
+    toJSON(): Record<string, any>;
+}
+
+/**
+ * ThreadManager manages all threads globally
+ * Provides methods to create, retrieve, and delete threads
+ */
+declare class ThreadManager {
+    private static instance;
+    private threads;
+    private constructor();
+    /**
+     * Get singleton instance of ThreadManager
+     */
+    static getInstance(): ThreadManager;
+    /**
+     * Create a new thread
+     * @param id - Optional custom ID, generates UUID if not provided
+     * @returns The created Thread instance
+     */
+    createThread(id?: string): Thread;
+    /**
+     * Get a thread by ID
+     */
+    getThread(id: string): Thread | undefined;
+    /**
+     * Get all threads
+     */
+    getAllThreads(): Thread[];
+    /**
+     * Get threads as a Map
+     */
+    getThreadsMap(): Map<string, Thread>;
+    /**
+     * Delete a thread by ID
+     */
+    deleteThread(id: string): boolean;
+    /**
+     * Check if thread exists
+     */
+    hasThread(id: string): boolean;
+    /**
+     * Get number of threads
+     */
+    getThreadCount(): number;
+    /**
+     * Clear all threads
+     */
+    clearAll(): void;
+    /**
+     * Find a UIBlock by ID across all threads
+     * @param uiBlockId - The UIBlock ID to search for
+     * @returns Object with thread and uiBlock if found, undefined otherwise
+     */
+    findUIBlockById(uiBlockId: string): {
+        thread: Thread;
+        uiBlock: UIBlock;
+    } | undefined;
+    /**
+     * Convert all threads to JSON-serializable object
+     */
+    toJSON(): Record<string, any>;
+}
+
+/**
+ * CleanupService handles cleanup of old threads and UIBlocks
+ * to prevent memory bloat and maintain optimal performance
+ */
+declare class CleanupService {
+    private static instance;
+    private cleanupInterval;
+    private constructor();
+    /**
+     * Get singleton instance of CleanupService
+     */
+    static getInstance(): CleanupService;
+    /**
+     * Clean up old threads based on retention period
+     * @param retentionDays - Number of days to keep threads (defaults to config)
+     * @returns Number of threads deleted
+     */
+    cleanupOldThreads(retentionDays?: number): number;
+    /**
+     * Clean up old UIBlocks within threads based on retention period
+     * @param retentionDays - Number of days to keep UIBlocks (defaults to config)
+     * @returns Object with number of UIBlocks deleted per thread
+     */
+    cleanupOldUIBlocks(retentionDays?: number): {
+        [threadId: string]: number;
+    };
+    /**
+     * Clear all component data from UIBlocks to free memory
+     * Keeps metadata but removes the actual data
+     * @param retentionDays - Number of days to keep full data (defaults to config)
+     * @returns Number of UIBlocks whose data was cleared
+     */
+    clearOldUIBlockData(retentionDays?: number): number;
+    /**
+     * Run full cleanup (threads, UIBlocks, and data)
+     * @returns Cleanup statistics
+     */
+    runFullCleanup(): {
+        threadsDeleted: number;
+        uiblocksDeleted: {
+            [threadId: string]: number;
+        };
+        dataCleared: number;
+    };
+    /**
+     * Start automatic cleanup at regular intervals
+     * @param intervalHours - Hours between cleanup runs (default: 24)
+     */
+    startAutoCleanup(intervalHours?: number): void;
+    /**
+     * Stop automatic cleanup
+     */
+    stopAutoCleanup(): void;
+    /**
+     * Check if auto cleanup is running
+     */
+    isAutoCleanupRunning(): boolean;
+    /**
+     * Get current memory usage statistics
+     */
+    getMemoryStats(): {
+        threadCount: number;
+        totalUIBlocks: number;
+        avgUIBlocksPerThread: number;
+    };
+}
+
+/**
+ * Configuration for data storage limits in UIBlocks
+ */
+declare const STORAGE_CONFIG: {
+    /**
+     * Maximum number of rows to store in UIBlock data
+     */
+    MAX_ROWS_PER_BLOCK: number;
+    /**
+     * Maximum size in bytes per UIBlock (1MB)
+     */
+    MAX_SIZE_PER_BLOCK_BYTES: number;
+    /**
+     * Number of days to keep threads before cleanup
+     */
+    THREAD_RETENTION_DAYS: number;
+    /**
+     * Number of days to keep UIBlocks before cleanup
+     */
+    UIBLOCK_RETENTION_DAYS: number;
+};
+
+/**
+ * Configuration for conversation context and history management
+ */
+declare const CONTEXT_CONFIG: {
+    /**
+     * Maximum number of previous UIBlocks to include as conversation context
+     * Set to 0 to disable conversation history
+     * Higher values provide more context but may increase token usage
+     */
+    MAX_CONVERSATION_CONTEXT_BLOCKS: number;
+};
+
+declare const SDK_VERSION = "0.0.8";
+type MessageTypeHandler = (message: IncomingMessage) => void | Promise<void>;
+declare class SuperatomSDK {
+    private ws;
+    private url;
+    private apiKey;
+    private projectId;
+    private userId;
+    private type;
+    private bundleDir;
+    private messageHandlers;
+    private messageTypeHandlers;
+    private connected;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private collections;
+    private components;
+    private anthropicApiKey;
+    private groqApiKey;
+    private llmProviders;
+    private userManager;
+    private dashboardManager;
+    private reportManager;
+    constructor(config: SuperatomSDKConfig);
+    /**
+     * Initialize UserManager for the project
+     */
+    private initializeUserManager;
+    /**
+     * Get the UserManager instance for this SDK
+     */
+    getUserManager(): UserManager;
+    /**
+     * Initialize DashboardManager for the project
+     */
+    private initializeDashboardManager;
+    /**
+     * Get the DashboardManager instance for this SDK
+     */
+    getDashboardManager(): DashboardManager;
+    /**
+     * Initialize ReportManager for the project
+     */
+    private initializeReportManager;
+    /**
+     * Get the ReportManager instance for this SDK
+     */
+    getReportManager(): ReportManager;
+    /**
+     * Connect to the Superatom WebSocket service
+     */
+    connect(): Promise<void>;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleMessage;
+    /**
+     * Send a message to the Superatom service
+     */
+    send(message: Message): void;
+    /**
+     * Register a message handler to receive all messages
+     */
+    onMessage(handler: (message: IncomingMessage) => void): () => void;
+    /**
+     * Register a handler for a specific message type
+     */
+    onMessageType(type: string, handler: MessageTypeHandler): () => void;
+    /**
+     * Disconnect from the WebSocket service
+     */
+    disconnect(): void;
+    /**
+     * Cleanup and disconnect - stops reconnection attempts and closes the connection
+     */
+    destroy(): Promise<void>;
+    /**
+     * Check if the SDK is currently connected
+     */
+    isConnected(): boolean;
+    /**
+     * Register a collection handler for data operations
+     */
+    addCollection<TParams = any, TResult = any>(collectionName: string, operation: CollectionOperation | string, handler: CollectionHandler<TParams, TResult>): void;
+    private handleReconnect;
+    private storeComponents;
+}
+
+export { type Action, CONTEXT_CONFIG, type CapturedLog, CleanupService, type CollectionHandler, type CollectionOperation, type IncomingMessage, LLM, type Message, SDK_VERSION, STORAGE_CONFIG, SuperatomSDK, type SuperatomSDKConfig, Thread, ThreadManager, UIBlock, UILogCollector, type User, UserManager, type UsersData };