@rainfall-devkit/sdk 0.1.1

package/dist/errors-DdRTwxpT.d.mts

@@ -0,0 +1,809 @@
+/**
+ * Core types for the Rainfall SDK
+ */
+interface RainfallConfig {
+    apiKey: string;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+}
+interface RequestOptions {
+    timeout?: number;
+    retries?: number;
+    retryDelay?: number;
+}
+interface ApiResponse<T = unknown> {
+    success: boolean;
+    data?: T;
+    error?: ApiError;
+}
+interface ApiError {
+    code: string;
+    message: string;
+    details?: Record<string, unknown>;
+}
+interface RateLimitInfo {
+    limit: number;
+    remaining: number;
+    resetAt: Date;
+}
+interface ToolSchema {
+    name: string;
+    description: string;
+    category: string;
+    parameters: unknown;
+    output: unknown;
+    metadata: Record<string, unknown>;
+}
+declare namespace Integrations {
+    interface GitHub {
+        issues: {
+            create(params: {
+                owner: string;
+                repo: string;
+                title: string;
+                body?: string;
+            }): Promise<unknown>;
+            list(params: {
+                owner: string;
+                repo: string;
+                state?: 'open' | 'closed' | 'all';
+            }): Promise<unknown>;
+            get(params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+            }): Promise<unknown>;
+            update(params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+                title?: string;
+                body?: string;
+                state?: 'open' | 'closed';
+            }): Promise<unknown>;
+            addComment(params: {
+                owner: string;
+                repo: string;
+                issue_number: number;
+                body: string;
+            }): Promise<unknown>;
+        };
+        repos: {
+            get(params: {
+                owner: string;
+                repo: string;
+            }): Promise<unknown>;
+            listBranches(params: {
+                owner: string;
+                repo: string;
+            }): Promise<unknown>;
+        };
+        pullRequests: {
+            list(params: {
+                owner: string;
+                repo: string;
+                state?: 'open' | 'closed' | 'all';
+            }): Promise<unknown>;
+            get(params: {
+                owner: string;
+                repo: string;
+                pullNumber: number;
+            }): Promise<unknown>;
+        };
+    }
+    interface Notion {
+        pages: {
+            create(params: {
+                parent: unknown;
+                properties: unknown;
+                children?: unknown[];
+            }): Promise<unknown>;
+            retrieve(params: {
+                pageId: string;
+            }): Promise<unknown>;
+            update(params: {
+                pageId: string;
+                properties: unknown;
+            }): Promise<unknown>;
+        };
+        databases: {
+            query(params: {
+                databaseId: string;
+                filter?: unknown;
+                sorts?: unknown[];
+            }): Promise<unknown>;
+            retrieve(params: {
+                databaseId: string;
+            }): Promise<unknown>;
+        };
+        blocks: {
+            appendChildren(params: {
+                blockId: string;
+                children: unknown[];
+            }): Promise<unknown>;
+            retrieveChildren(params: {
+                blockId: string;
+            }): Promise<unknown>;
+        };
+    }
+    interface Linear {
+        issues: {
+            create(params: {
+                title: string;
+                description?: string;
+                teamId?: string;
+                assigneeId?: string;
+                priority?: number;
+                labels?: string[];
+            }): Promise<unknown>;
+            list(params?: {
+                filter?: unknown;
+                orderBy?: string;
+            }): Promise<unknown>;
+            get(params: {
+                issueId: string;
+            }): Promise<unknown>;
+            update(params: {
+                issueId: string;
+                title?: string;
+                description?: string;
+                state?: string;
+            }): Promise<unknown>;
+            archive(params: {
+                issueId: string;
+            }): Promise<unknown>;
+        };
+        teams: {
+            list(): Promise<unknown>;
+        };
+    }
+    interface Slack {
+        messages: {
+            send(params: {
+                channelId: string;
+                text: string;
+                blocks?: unknown[];
+            }): Promise<unknown>;
+            list(params: {
+                channelId: string;
+                limit?: number;
+            }): Promise<unknown>;
+        };
+        channels: {
+            list(): Promise<unknown>;
+        };
+        users: {
+            list(): Promise<unknown>;
+        };
+        reactions: {
+            add(params: {
+                channelId: string;
+                timestamp: string;
+                reaction: string;
+            }): Promise<unknown>;
+        };
+    }
+    interface Figma {
+        files: {
+            get(params: {
+                fileKey: string;
+            }): Promise<unknown>;
+            getNodes(params: {
+                fileKey: string;
+                nodeIds: string[];
+            }): Promise<unknown>;
+            getImages(params: {
+                fileKey: string;
+                nodeIds: string[];
+                format?: 'png' | 'svg' | 'pdf';
+            }): Promise<unknown>;
+            getComments(params: {
+                fileKey: string;
+            }): Promise<unknown>;
+            postComment(params: {
+                fileKey: string;
+                message: string;
+                nodeId?: string;
+            }): Promise<unknown>;
+        };
+        projects: {
+            list(params: {
+                teamId: string;
+            }): Promise<unknown>;
+            getFiles(params: {
+                projectId: string;
+            }): Promise<unknown>;
+        };
+    }
+    interface Stripe {
+        customers: {
+            create(params: {
+                email: string;
+                name?: string;
+                metadata?: Record<string, string>;
+            }): Promise<unknown>;
+            retrieve(params: {
+                customerId: string;
+            }): Promise<unknown>;
+            update(params: {
+                customerId: string;
+                metadata?: Record<string, string>;
+            }): Promise<unknown>;
+            listPaymentMethods(params: {
+                customerId: string;
+            }): Promise<unknown>;
+        };
+        paymentIntents: {
+            create(params: {
+                amount: number;
+                currency: string;
+                customer?: string;
+            }): Promise<unknown>;
+            retrieve(params: {
+                paymentIntentId: string;
+            }): Promise<unknown>;
+            confirm(params: {
+                paymentIntentId: string;
+            }): Promise<unknown>;
+        };
+        subscriptions: {
+            create(params: {
+                customer: string;
+                items: unknown[];
+            }): Promise<unknown>;
+            retrieve(params: {
+                subscriptionId: string;
+            }): Promise<unknown>;
+            cancel(params: {
+                subscriptionId: string;
+            }): Promise<unknown>;
+        };
+    }
+}
+declare namespace Memory {
+    interface MemoryClient {
+        create(params: {
+            content: string;
+            keywords?: string[];
+            metadata?: Record<string, unknown>;
+        }): Promise<unknown>;
+        get(params: {
+            memoryId: string;
+        }): Promise<unknown>;
+        recall(params: {
+            query: string;
+            topK?: number;
+            threshold?: number;
+        }): Promise<unknown>;
+        list(params?: {
+            limit?: number;
+            offset?: number;
+        }): Promise<unknown>;
+        update(params: {
+            memoryId: string;
+            content?: string;
+            metadata?: Record<string, unknown>;
+        }): Promise<unknown>;
+        delete(params: {
+            memoryId: string;
+        }): Promise<unknown>;
+    }
+}
+declare namespace Articles {
+    interface ArticlesClient {
+        search(params: {
+            query: string;
+            limit?: number;
+        }): Promise<unknown>;
+        create(params: {
+            title: string;
+            content: string;
+            topics?: string[];
+            metadata?: Record<string, unknown>;
+        }): Promise<unknown>;
+        createFromUrl(params: {
+            url: string;
+        }): Promise<unknown>;
+        fetch(params: {
+            articleId: string;
+        }): Promise<unknown>;
+        recent(params?: {
+            limit?: number;
+        }): Promise<unknown>;
+        relevant(params: {
+            query: string;
+            limit?: number;
+        }): Promise<unknown>;
+        summarize(params: {
+            articleId?: string;
+            text?: string;
+            length?: 'short' | 'medium' | 'long';
+        }): Promise<unknown>;
+        extractTopics(params: {
+            text: string;
+        }): Promise<unknown>;
+    }
+}
+declare namespace Web {
+    interface WebClient {
+        search: {
+            exa(params: {
+                query: string;
+                numResults?: number;
+                includeDomains?: string[];
+                excludeDomains?: string[];
+            }): Promise<unknown>;
+            perplexity(params: {
+                query: string;
+            }): Promise<unknown>;
+        };
+        fetch(params: {
+            url: string;
+            headers?: Record<string, string>;
+        }): Promise<unknown>;
+        htmlToMarkdown(params: {
+            html: string;
+            baseUrl?: string;
+        }): Promise<unknown>;
+        extractHtml(params: {
+            html: string;
+            selector: string;
+        }): Promise<unknown>;
+    }
+}
+declare namespace AI {
+    interface AIClient {
+        embeddings: {
+            document(params: {
+                text: string;
+            }): Promise<unknown>;
+            query(params: {
+                text: string;
+            }): Promise<unknown>;
+            image(params: {
+                imageBase64: string;
+            }): Promise<unknown>;
+        };
+        image: {
+            generate(params: {
+                prompt: string;
+                size?: '256x256' | '512x512' | '1024x1024';
+            }): Promise<unknown>;
+        };
+        ocr(params: {
+            imageBase64: string;
+        }): Promise<unknown>;
+        vision(params: {
+            imageBase64: string;
+            prompt?: string;
+        }): Promise<unknown>;
+        chat(params: {
+            messages: Array<{
+                role: 'user' | 'assistant' | 'system';
+                content: string;
+            }>;
+            model?: string;
+        }): Promise<unknown>;
+        complete(params: {
+            prompt: string;
+            suffix?: string;
+        }): Promise<unknown>;
+        classify(params: {
+            text: string;
+            labels: string[];
+        }): Promise<unknown>;
+        segment(params: {
+            text: string;
+            maxLength?: number;
+        }): Promise<unknown[]>;
+    }
+}
+declare namespace Data {
+    interface DataClient {
+        csv: {
+            query(params: {
+                sql: string;
+                csvData?: string;
+                fileId?: string;
+            }): Promise<unknown>;
+            convert(params: {
+                data: string;
+                fromFormat: string;
+                toFormat: string;
+            }): Promise<unknown>;
+        };
+        scripts: {
+            create(params: {
+                name: string;
+                code: string;
+                language?: string;
+            }): Promise<unknown>;
+            execute(params: {
+                name: string;
+                params?: Record<string, unknown>;
+            }): Promise<unknown>;
+            list(): Promise<unknown>;
+            update(params: {
+                name: string;
+                code: string;
+            }): Promise<unknown>;
+            delete(params: {
+                name: string;
+            }): Promise<unknown>;
+        };
+        similarity: {
+            search(params: {
+                query: number[];
+                embeddings: number[][];
+                topK?: number;
+            }): Promise<unknown>;
+            duckDbSearch(params: {
+                query: number[];
+                tableName: string;
+            }): Promise<unknown>;
+        };
+    }
+}
+declare namespace Utils {
+    interface UtilsClient {
+        mermaid(params: {
+            diagram: string;
+        }): Promise<unknown>;
+        documentConvert(params: {
+            document: string;
+            mimeType: string;
+            format: string;
+        }): Promise<unknown>;
+        regex: {
+            match(params: {
+                text: string;
+                pattern: string;
+                flags?: string;
+            }): Promise<unknown>;
+            replace(params: {
+                text: string;
+                pattern: string;
+                replacement: string;
+                flags?: string;
+            }): Promise<unknown>;
+        };
+        jsonExtract(params: {
+            text: string;
+        }): Promise<unknown>;
+        digest(params: {
+            data: string;
+        }): Promise<string>;
+        monteCarlo(params: {
+            iterations?: number;
+            formula: string;
+            variables?: Record<string, {
+                mean: number;
+                stdDev: number;
+            }>;
+        }): Promise<unknown>;
+    }
+}
+
+/**
+ * Core HTTP client for Rainfall SDK
+ */
+
+declare class RainfallClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly defaultTimeout;
+    private readonly defaultRetries;
+    private readonly defaultRetryDelay;
+    private lastRateLimitInfo?;
+    constructor(config: RainfallConfig);
+    /**
+     * Get the last rate limit info from the API
+     */
+    getRateLimitInfo(): RateLimitInfo | undefined;
+    /**
+     * Make an authenticated request to the Rainfall API
+     */
+    request<T = unknown>(path: string, options?: {
+        method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+        body?: unknown;
+        headers?: Record<string, string>;
+    }, requestOptions?: RequestOptions): Promise<T>;
+    /**
+     * Execute a tool/node by ID
+     */
+    executeTool<T = unknown>(toolId: string, params?: Record<string, unknown>, options?: RequestOptions): Promise<T>;
+    /**
+     * List all available tools
+     */
+    listTools(): Promise<Array<{
+        id: string;
+        name: string;
+        description: string;
+        category: string;
+    }>>;
+    /**
+     * Get tool schema/parameters
+     */
+    getToolSchema(toolId: string): Promise<ToolSchema>;
+    /**
+     * Get subscriber info
+     */
+    getMe(): Promise<{
+        id: string;
+        email: string;
+        plan: string;
+        usage: {
+            callsThisMonth: number;
+            callsLimit: number;
+        };
+    }>;
+    private sleep;
+}
+
+/**
+ * Integrations namespace for Rainfall SDK
+ * GitHub, Notion, Linear, Slack, Figma, Stripe
+ */
+
+declare class IntegrationsNamespace {
+    private client;
+    constructor(client: RainfallClient);
+    get github(): Integrations.GitHub;
+    get notion(): Integrations.Notion;
+    get linear(): Integrations.Linear;
+    get slack(): Integrations.Slack;
+    get figma(): Integrations.Figma;
+    get stripe(): Integrations.Stripe;
+}
+
+declare class Rainfall {
+    private readonly client;
+    private _integrations?;
+    private _memory?;
+    private _articles?;
+    private _web?;
+    private _ai?;
+    private _data?;
+    private _utils?;
+    constructor(config: RainfallConfig);
+    /**
+     * Integrations namespace - GitHub, Notion, Linear, Slack, Figma, Stripe
+     *
+     * @example
+     * ```typescript
+     * // GitHub
+     * await rainfall.integrations.github.issues.create({
+     *   owner: 'facebook',
+     *   repo: 'react',
+     *   title: 'Bug report'
+     * });
+     *
+     * // Slack
+     * await rainfall.integrations.slack.messages.send({
+     *   channelId: 'C123456',
+     *   text: 'Hello team!'
+     * });
+     *
+     * // Linear
+     * const issues = await rainfall.integrations.linear.issues.list();
+     * ```
+     */
+    get integrations(): IntegrationsNamespace;
+    /**
+     * Memory namespace - Semantic memory storage and retrieval
+     *
+     * @example
+     * ```typescript
+     * // Store a memory
+     * await rainfall.memory.create({
+     *   content: 'User prefers dark mode',
+     *   keywords: ['preference', 'ui']
+     * });
+     *
+     * // Recall similar memories
+     * const memories = await rainfall.memory.recall({
+     *   query: 'user preferences',
+     *   topK: 5
+     * });
+     * ```
+     */
+    get memory(): Memory.MemoryClient;
+    /**
+     * Articles namespace - News aggregation and article management
+     *
+     * @example
+     * ```typescript
+     * // Search news
+     * const articles = await rainfall.articles.search({
+     *   query: 'artificial intelligence'
+     * });
+     *
+     * // Create from URL
+     * const article = await rainfall.articles.createFromUrl({
+     *   url: 'https://example.com/article'
+     * });
+     *
+     * // Summarize
+     * const summary = await rainfall.articles.summarize({
+     *   text: article.content
+     * });
+     * ```
+     */
+    get articles(): Articles.ArticlesClient;
+    /**
+     * Web namespace - Web search, scraping, and content extraction
+     *
+     * @example
+     * ```typescript
+     * // Search with Exa
+     * const results = await rainfall.web.search.exa({
+     *   query: 'latest AI research'
+     * });
+     *
+     * // Fetch and convert
+     * const html = await rainfall.web.fetch({ url: 'https://example.com' });
+     * const markdown = await rainfall.web.htmlToMarkdown({ html });
+     *
+     * // Extract specific elements
+     * const links = await rainfall.web.extractHtml({
+     *   html,
+     *   selector: 'a[href]'
+     * });
+     * ```
+     */
+    get web(): Web.WebClient;
+    /**
+     * AI namespace - Embeddings, image generation, OCR, vision, chat
+     *
+     * @example
+     * ```typescript
+     * // Generate embeddings
+     * const embedding = await rainfall.ai.embeddings.document({
+     *   text: 'Hello world'
+     * });
+     *
+     * // Generate image
+     * const image = await rainfall.ai.image.generate({
+     *   prompt: 'A serene mountain landscape'
+     * });
+     *
+     * // OCR
+     * const text = await rainfall.ai.ocr({ imageBase64: '...' });
+     *
+     * // Chat
+     * const response = await rainfall.ai.chat({
+     *   messages: [{ role: 'user', content: 'Hello!' }]
+     * });
+     * ```
+     */
+    get ai(): AI.AIClient;
+    /**
+     * Data namespace - CSV processing, scripts, similarity search
+     *
+     * @example
+     * ```typescript
+     * // Query CSV with SQL
+     * const results = await rainfall.data.csv.query({
+     *   sql: 'SELECT * FROM data WHERE value > 100'
+     * });
+     *
+     * // Execute saved script
+     * const result = await rainfall.data.scripts.execute({
+     *   name: 'my-script',
+     *   params: { input: 'data' }
+     * });
+     * ```
+     */
+    get data(): Data.DataClient;
+    /**
+     * Utils namespace - Mermaid diagrams, document conversion, regex, JSON extraction
+     *
+     * @example
+     * ```typescript
+     * // Generate diagram
+     * const diagram = await rainfall.utils.mermaid({
+     *   diagram: 'graph TD; A-->B;'
+     * });
+     *
+     * // Convert document
+     * const pdf = await rainfall.utils.documentConvert({
+     *   document: markdownContent,
+     *   mimeType: 'text/markdown',
+     *   format: 'pdf'
+     * });
+     *
+     * // Extract JSON from text
+     * const json = await rainfall.utils.jsonExtract({
+     *   text: 'Here is some data: {"key": "value"}'
+     * });
+     * ```
+     */
+    get utils(): Utils.UtilsClient;
+    /**
+     * Get the underlying HTTP client for advanced usage
+     */
+    getClient(): RainfallClient;
+    /**
+     * List all available tools
+     */
+    listTools(): Promise<{
+        id: string;
+        name: string;
+        description: string;
+        category: string;
+    }[]>;
+    /**
+     * Get schema for a specific tool
+     */
+    getToolSchema(toolId: string): Promise<ToolSchema>;
+    /**
+     * Execute any tool by ID (low-level access)
+     */
+    executeTool<T = unknown>(toolId: string, params?: Record<string, unknown>): Promise<T>;
+    /**
+     * Get current subscriber info and usage
+     */
+    getMe(): Promise<{
+        id: string;
+        email: string;
+        plan: string;
+        usage: {
+            callsThisMonth: number;
+            callsLimit: number;
+        };
+    }>;
+    /**
+     * Get current rate limit info
+     */
+    getRateLimitInfo(): RateLimitInfo | undefined;
+}
+
+/**
+ * Error classes for Rainfall SDK
+ */
+declare class RainfallError extends Error {
+    readonly code: string;
+    readonly statusCode?: number | undefined;
+    readonly details?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined, details?: Record<string, unknown> | undefined);
+    toJSON(): {
+        name: string;
+        code: string;
+        message: string;
+        statusCode: number | undefined;
+        details: Record<string, unknown> | undefined;
+    };
+}
+declare class AuthenticationError extends RainfallError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class RateLimitError extends RainfallError {
+    readonly retryAfter: number;
+    readonly limit: number;
+    readonly remaining: number;
+    readonly resetAt: Date;
+    constructor(message?: string, retryAfter?: number, limit?: number, remaining?: number, resetAt?: Date);
+}
+declare class ValidationError extends RainfallError {
+    constructor(message: string, details?: Record<string, unknown>);
+}
+declare class NotFoundError extends RainfallError {
+    constructor(resource: string, identifier?: string);
+}
+declare class ServerError extends RainfallError {
+    constructor(message?: string, statusCode?: number);
+}
+declare class TimeoutError extends RainfallError {
+    constructor(timeoutMs: number);
+}
+declare class NetworkError extends RainfallError {
+    constructor(message?: string, details?: Record<string, unknown>);
+}
+declare class ToolNotFoundError extends RainfallError {
+    constructor(toolId: string);
+}
+declare function parseErrorResponse(response: Response, data: unknown): RainfallError;
+
+export { AI as A, Data as D, Integrations as I, Memory as M, NetworkError as N, Rainfall as R, ServerError as S, TimeoutError as T, Utils as U, ValidationError as V, Web as W, type ApiError as a, type ApiResponse as b, Articles as c, AuthenticationError as d, NotFoundError as e, RainfallClient as f, type RainfallConfig as g, RainfallError as h, RateLimitError as i, type RateLimitInfo as j, type RequestOptions as k, ToolNotFoundError as l, type ToolSchema as m, parseErrorResponse as p };