@daf-sdk/runtime 1.0.0

package/dist/runtime/index.d.mts

@@ -0,0 +1,957 @@
+import * as _ai_sdk_provider from '@ai-sdk/provider';
+import * as google_auth_library from 'google-auth-library';
+
+interface UserProviderSettings {
+    openaiApiKey?: string | null;
+    anthropicApiKey?: string | null;
+    mistralApiKey?: string | null;
+    googleApiKey?: string | null;
+    xaiApiKey?: string | null;
+    deepseekApiKey?: string | null;
+    useOpenaiKey: boolean;
+    useAnthropicKey: boolean;
+    useMistralKey: boolean;
+    useGoogleKey: boolean;
+    useXaiKey: boolean;
+    useDeepseekKey: boolean;
+    tier: string;
+    tokensUsedThisMonth: number;
+    walletBalance: number;
+}
+interface TokenUsage {
+    inputTokens: number;
+    outputTokens: number;
+    cachedTokens: number;
+    reasoningTokens: number;
+    totalTokens: number;
+    costUsd: number;
+    model: string;
+}
+interface DAFRunRecord {
+    id: string;
+    status: string;
+    messages: any[];
+    metadata: any;
+    model: string;
+    userId: string;
+    processId: string;
+}
+interface DAFProcessRecord {
+    id: string;
+    name: string;
+    steps: any[];
+    userId: string;
+    description?: string | null;
+    resourceIds?: string[];
+    resources?: any[];
+}
+interface DAFUserRecord {
+    id: string;
+    email: string;
+    name?: string | null;
+    tier: string;
+    tokensUsedThisMonth: number;
+    walletBalance: number;
+    lastMonthlyReset: Date;
+    openaiApiKey?: string | null;
+    anthropicApiKey?: string | null;
+    mistralApiKey?: string | null;
+    googleApiKey?: string | null;
+    xaiApiKey?: string | null;
+    deepseekApiKey?: string | null;
+    useOpenaiKey: boolean;
+    useAnthropicKey: boolean;
+    useMistralKey: boolean;
+    useGoogleKey: boolean;
+    useXaiKey: boolean;
+    useDeepseekKey: boolean;
+    variables?: Record<string, string>;
+}
+interface DAFResourceRecord {
+    id?: string;
+    name: string;
+    type: string;
+    provider: string;
+    url: string;
+}
+interface DAFGoogleIntegration {
+    id: string;
+    accessToken: string;
+    refreshToken?: string | null;
+    expiresAt?: Date | null;
+}
+interface DAFNotionIntegration {
+    id: string;
+    accessToken: string;
+}
+interface DAFEmailIntegration {
+    host: string;
+    port: number;
+    user: string;
+    pass: string;
+    from?: string;
+}
+interface DAFStorageAdapter {
+    getRun(runId: string): Promise<DAFRunRecord | null>;
+    createRun(data: Omit<DAFRunRecord, 'id'>): Promise<DAFRunRecord>;
+    updateRun(runId: string, data: Partial<Omit<DAFRunRecord, 'id'>>): Promise<void>;
+    countRunningRuns(userId: string): Promise<number>;
+    getRunningRuns(processId: string): Promise<DAFRunRecord[]>;
+    getProcess(processId: string, userId: string): Promise<DAFProcessRecord | null>;
+    getProcesses(processIds: string[], userId: string): Promise<DAFProcessRecord[]>;
+    updateProcess(processId: string, data: Partial<DAFProcessRecord>): Promise<void>;
+    getUser(userId: string): Promise<DAFUserRecord | null>;
+    updateUserUsage(userId: string, usage: TokenUsage): Promise<{
+        newBalance: number;
+        newTokenCount: number;
+    }>;
+    getResourcesForProcess(processId: string, userId: string, parentProcessIds?: string[]): Promise<DAFResourceRecord[]>;
+    getResourcesByIds(resourceIds: string[], userId: string): Promise<DAFResourceRecord[]>;
+    getUserVariables(userId: string): Promise<Record<string, string>>;
+    getGoogleIntegration(userId: string): Promise<DAFGoogleIntegration | null>;
+    updateGoogleIntegration(integrationId: string, data: {
+        accessToken: string;
+        expiresAt: Date;
+    }): Promise<void>;
+    getNotionIntegration(userId: string): Promise<DAFNotionIntegration | null>;
+    getEmailIntegration(userId: string): Promise<DAFEmailIntegration | null>;
+    pauseUserSchedules?(userId: string): Promise<void>;
+    getScheduleForProcess?(processId: string): Promise<{
+        id: string;
+    } | null>;
+    onMonthlyLimitReached?(userId: string, user: any): Promise<void>;
+    onWalletDepleted?(userId: string, user: any): Promise<void>;
+    db: {
+        user: {
+            findUnique(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            update(args: {
+                where: Record<string, any>;
+                data: Record<string, any>;
+            }): Promise<any>;
+        };
+        run: {
+            create(args: {
+                data: Record<string, any>;
+            }): Promise<any>;
+            update(args: {
+                where: Record<string, any>;
+                data: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any>;
+            findUnique(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            findFirst(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            findMany(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+                orderBy?: Record<string, any>;
+            }): Promise<any[]>;
+            count(args: {
+                where: Record<string, any>;
+            }): Promise<number>;
+        };
+        resource: {
+            create(args: {
+                data: Record<string, any>;
+            }): Promise<any>;
+            update(args: {
+                where: Record<string, any>;
+                data: Record<string, any>;
+            }): Promise<void>;
+            delete(args: {
+                where: Record<string, any>;
+            }): Promise<void>;
+            findFirst(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            findMany(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any[]>;
+        };
+        process: {
+            findUnique(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            findFirst(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            findMany(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any[]>;
+            update(args: {
+                where: Record<string, any>;
+                data: Record<string, any>;
+            }): Promise<void>;
+        };
+        integration: {
+            findUnique(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+        };
+        schedule: {
+            findFirst(args: {
+                where: Record<string, any>;
+                select?: Record<string, any>;
+            }): Promise<any | null>;
+            updateMany(args: {
+                where: Record<string, any>;
+                data: Record<string, any>;
+            }): Promise<void>;
+        };
+    };
+    emitRunUpdate(runId: string, event: any): void;
+    emitRunListUpdate(userId: string, event: any): void;
+    emitRunningCountUpdate(userId: string, count: number): void;
+    log: {
+        info(msg: string, ...args: any[]): void;
+        warn(msg: string, ...args: any[]): void;
+        error(msg: string, ...args: any[]): void;
+    };
+}
+interface ActionConfig {
+    firecrawlApiKey?: string;
+    serpApiKey?: string;
+    tavilyApiKey?: string;
+}
+interface ExecutionContext {
+    model: string;
+    modelProvider: any;
+    onTokenUsage?: (input: number, output: number, total: number, cached: number, reasoning: number) => Promise<void>;
+    isChatContext?: boolean;
+}
+
+declare const TIER_TOKEN_LIMITS: Record<string, number>;
+declare const MODEL_PRICING: Record<string, {
+    input: number;
+    output: number;
+    cachedInput?: number;
+}>;
+declare function calculateTokenCost(model: string | undefined, inputTokens: number, outputTokens: number, cachedInputTokens?: number, reasoningTokens?: number): number;
+declare function buildTokenUsage(model: string, inputTokens: number, outputTokens: number, cachedTokens?: number, reasoningTokens?: number): TokenUsage;
+
+declare function getProviderFromModel(modelName: string): string;
+declare function getModelProvider(modelName: string, userSettings?: UserProviderSettings | null): _ai_sdk_provider.LanguageModelV3;
+
+/**
+ * Generic Variables - System-defined variables that help users reference actions
+ * These are read-only and available to all users
+ */
+interface GenericVariable {
+    name: string;
+    value: string;
+    description: string;
+}
+declare const GENERIC_VARIABLES: Record<string, string>;
+declare function getDescEditorActions(): string;
+declare function getDescAllActions(): string;
+declare function getDescChatActions(): string;
+/**
+ * Get all generic variables as a record
+ */
+declare function getGenericVariables(): Record<string, string>;
+/**
+ * Get a specific generic variable by name
+ */
+declare function getGenericVariable(name: string): string | undefined;
+/**
+ * Check if a variable name is a generic variable
+ */
+declare function isGenericVariable(name: string): boolean;
+/**
+ * Get variable names (for autocomplete/picker)
+ */
+declare function getGenericVariableNames(): string[];
+/**
+ * Merge generic variables with user variables
+ * User variables take precedence over generic variables
+ */
+declare function mergeVariables(userVariables: Record<string, string>): Record<string, string>;
+
+interface SendEmailAction {
+    type: 'action';
+    variant: 'sendEmail';
+    parameters: {
+        to: string;
+        subject: string;
+        content: string;
+        from_name?: string;
+    };
+}
+interface ReadDocumentAction {
+    type: 'action';
+    variant: 'readDocument';
+    parameters: {
+        resourceUrl: string;
+    };
+}
+interface WriteDocumentAction {
+    type: 'action';
+    variant: 'writeDocument';
+    parameters: {
+        resourceUrl: string;
+        content: string;
+        mode?: 'replace' | 'append' | 'selective';
+        range?: {
+            startIndex: number;
+            endIndex: number;
+        };
+    };
+}
+interface FormatDocumentAction {
+    type: 'action';
+    variant: 'formatDocument';
+    parameters: {
+        resourceUrl: string;
+        range?: {
+            startIndex: number;
+            endIndex: number;
+        };
+        formatting: {
+            bold?: boolean;
+            italic?: boolean;
+            fontSize?: number;
+        };
+    };
+}
+interface RemoveDocumentAction {
+    type: 'action';
+    variant: 'removeDocument';
+    parameters: {
+        resourceUrl: string;
+    };
+}
+interface RenameDocumentAction {
+    type: 'action';
+    variant: 'renameDocument';
+    parameters: {
+        resourceUrl: string;
+        newName: string;
+    };
+}
+interface DuplicateDocumentAction {
+    type: 'action';
+    variant: 'duplicateDocument';
+    parameters: {
+        resourceUrl: string;
+        newName: string;
+    };
+}
+interface AddFolderAction {
+    type: 'action';
+    variant: 'addFolder';
+    parameters: {
+        folderName: string;
+        parentUrl?: string;
+        provider: 'google' | 'notion';
+    };
+}
+interface RemoveFolderAction {
+    type: 'action';
+    variant: 'removeFolder';
+    parameters: {
+        folderUrl: string;
+    };
+}
+interface ReadFolderAction {
+    type: 'action';
+    variant: 'readFolder';
+    parameters: {
+        folderUrl: string;
+    };
+}
+interface RenameFolderAction {
+    type: 'action';
+    variant: 'renameFolder';
+    parameters: {
+        folderUrl: string;
+        newName: string;
+    };
+}
+interface AddDocumentAction {
+    type: 'action';
+    variant: 'addDocument';
+    parameters: {
+        locationUrl?: string;
+        documentName: string;
+        content?: string;
+        provider: 'google' | 'notion';
+    };
+}
+interface CreateDatabaseAction {
+    type: 'action';
+    variant: 'createDatabase';
+    parameters: {
+        parentPageUrl?: string;
+        databaseName: string;
+    };
+}
+interface ReadDatabaseAction {
+    type: 'action';
+    variant: 'readDatabase';
+    parameters: {
+        databaseUrl: string;
+    };
+}
+interface UpdateDatabaseAction {
+    type: 'action';
+    variant: 'updateDatabase';
+    parameters: {
+        databaseUrl: string;
+        databaseName?: string;
+        properties?: Record<string, any>;
+    };
+}
+interface DeleteDatabaseAction {
+    type: 'action';
+    variant: 'deleteDatabase';
+    parameters: {
+        databaseUrl: string;
+    };
+}
+interface WriteDatabaseAction {
+    type: 'action';
+    variant: 'writeDatabase';
+    parameters: {
+        databaseUrl: string;
+        properties: Record<string, any>;
+        content?: string;
+    };
+}
+interface DuplicateDatabaseAction {
+    type: 'action';
+    variant: 'duplicateDatabase';
+    parameters: {
+        databaseUrl: string;
+        newDatabaseName?: string;
+    };
+}
+type FirecrawlActionType = {
+    type: 'wait';
+    milliseconds?: number;
+    selector?: string;
+} | {
+    type: 'click';
+    selector: string;
+} | {
+    type: 'write';
+    text: string;
+    selector?: string;
+} | {
+    type: 'press';
+    key: string;
+} | {
+    type: 'scroll';
+    direction?: 'up' | 'down';
+    selector?: string;
+    amount?: number;
+} | {
+    type: 'screenshot';
+    fullPage?: boolean;
+} | {
+    type: 'scrape';
+};
+interface LocationSettings {
+    country?: string;
+    languages?: string[];
+}
+interface JsonFormatOptions {
+    type: 'json';
+    schema?: any;
+    prompt?: string;
+}
+interface ScreenshotFormatOptions {
+    type: 'screenshot';
+    fullPage?: boolean;
+    quality?: number;
+    viewport?: {
+        width: number;
+        height: number;
+    };
+}
+type ScrapeFormat = 'markdown' | 'html' | 'rawHtml' | 'links' | 'screenshot' | 'summary' | JsonFormatOptions | ScreenshotFormatOptions;
+interface ScrapeAction {
+    type: 'action';
+    variant: 'scrape';
+    parameters: {
+        url: string;
+        timeout?: number;
+    };
+}
+interface SearchAction {
+    type: 'action';
+    variant: 'search';
+    parameters: {
+        query: string;
+        limit?: number;
+        ignoreInvalidURLs?: boolean;
+        sources?: Array<'web' | 'news' | 'images'>;
+        categories?: Array<'github' | 'research' | 'pdf'>;
+        tbs?: string;
+        location?: string;
+        scrapeOptions?: {
+            formats?: string[];
+            onlyMainContent?: boolean;
+            timeout?: number;
+            maxAge?: number;
+            parsers?: Array<{
+                type: string;
+                maxPages?: number;
+            }>;
+            proxy?: 'basic' | 'enhanced' | 'auto';
+        };
+    };
+}
+interface NewsSearchAction {
+    type: 'action';
+    variant: 'newsSearch';
+    parameters: {
+        query: string;
+        limit?: number;
+        ignoreInvalidURLs?: boolean;
+        tbs?: string;
+        location?: string;
+        scrapeOptions?: {
+            formats?: string[];
+            onlyMainContent?: boolean;
+            timeout?: number;
+            maxAge?: number;
+            parsers?: Array<{
+                type: string;
+                maxPages?: number;
+            }>;
+            proxy?: 'basic' | 'enhanced' | 'auto';
+        };
+    };
+}
+interface QuickSearchAction {
+    type: 'action';
+    variant: 'previewSearch';
+    parameters: {
+        query: string;
+        limit?: number;
+        sources?: Array<'web' | 'news'>;
+    };
+}
+interface TavilySearchAction {
+    type: 'action';
+    variant: 'tavilySearch';
+    parameters: {
+        query: string;
+        maxResults?: number;
+        searchDepth?: 'basic' | 'advanced';
+        includeAnswer?: boolean;
+    };
+}
+interface WebhookConfig {
+    url: string;
+    metadata?: Record<string, any>;
+    events?: ('started' | 'page' | 'completed' | 'failed')[];
+}
+interface CrawlAction {
+    type: 'action';
+    variant: 'crawl';
+    parameters: {
+        url: string;
+        limit?: number;
+        maxDepth?: number;
+        allowBackwardLinks?: boolean;
+        allowExternalLinks?: boolean;
+        allowSubdomains?: boolean;
+        crawlEntireDomain?: boolean;
+        ignoreSitemap?: boolean;
+        includePaths?: string[];
+        excludePaths?: string[];
+        maxFileSize?: number;
+        webhook?: WebhookConfig;
+        scrapeOptions?: {
+            formats?: ScrapeFormat[];
+            onlyMainContent?: boolean;
+            includeTags?: string[];
+            excludeTags?: string[];
+            headers?: Record<string, string>;
+            waitFor?: number;
+            maxAge?: number;
+            storeInCache?: boolean;
+            actions?: FirecrawlActionType[];
+            location?: LocationSettings;
+            mobile?: boolean;
+            skipTlsVerification?: boolean;
+            removeBase64Images?: boolean;
+        };
+    };
+}
+interface EditorTransformAction {
+    type: 'editorAction';
+    variant: 'fixSpellingGrammar' | 'rewrite' | 'extendText' | 'addText' | 'reduceText' | 'removeText' | 'simplify' | 'completeSentence' | 'translate' | 'formatText' | 'directive';
+    parameters: {
+        selectedText: string;
+        language?: string;
+        directive?: string;
+        from?: number;
+        to?: number;
+    };
+}
+interface DbFindAction {
+    type: 'action';
+    variant: 'dbFind';
+    parameters: {
+        resourceUrl: string;
+        filter?: Record<string, unknown>;
+        sort?: Record<string, 1 | -1>;
+        limit?: number;
+        projection?: Record<string, 0 | 1>;
+    };
+}
+interface DbInsertAction {
+    type: 'action';
+    variant: 'dbInsert';
+    parameters: {
+        resourceUrl: string;
+        document: Record<string, unknown>;
+    };
+}
+interface DbUpdateAction {
+    type: 'action';
+    variant: 'dbUpdate';
+    parameters: {
+        resourceUrl: string;
+        filter: Record<string, unknown>;
+        update: Record<string, unknown>;
+        multi?: boolean;
+        upsert?: boolean;
+    };
+}
+interface DbDeleteAction {
+    type: 'action';
+    variant: 'dbDelete';
+    parameters: {
+        resourceUrl: string;
+        filter: Record<string, unknown>;
+        multi?: boolean;
+        confirm: true;
+    };
+}
+interface AskUserInputAction {
+    type: 'action';
+    variant: 'askUserInput';
+    parameters: {
+        message?: string;
+    };
+}
+type Action = SendEmailAction | ScrapeAction | SearchAction | NewsSearchAction | QuickSearchAction | TavilySearchAction | CrawlAction | ReadDocumentAction | WriteDocumentAction | FormatDocumentAction | RemoveDocumentAction | RenameDocumentAction | DuplicateDocumentAction | AddFolderAction | RemoveFolderAction | ReadFolderAction | RenameFolderAction | AddDocumentAction | CreateDatabaseAction | ReadDatabaseAction | UpdateDatabaseAction | DeleteDatabaseAction | WriteDatabaseAction | DuplicateDatabaseAction | DbFindAction | DbInsertAction | DbUpdateAction | DbDeleteAction | EditorTransformAction | AskUserInputAction;
+interface ActionResult {
+    success: boolean;
+    error?: string;
+    message?: string;
+    data?: any;
+    pauseForInput?: boolean;
+}
+declare function extractActionsFromMessage(message: string): Action[];
+declare function executeAction(action: Action, userId?: string, adapter?: DAFStorageAdapter, processId?: string, parentProcessIds?: string[], context?: ExecutionContext): Promise<ActionResult>;
+declare function processMessageActions(message: string, userId?: string, adapter?: DAFStorageAdapter, processId?: string, parentProcessIds?: string[], context?: ExecutionContext): Promise<{
+    originalMessage: string;
+    processedMessage: string;
+    actionResults: ActionResult[];
+    hasActions: boolean;
+}>;
+
+/**
+ * Pre-check if user has any available credits BEFORE making API call
+ * This prevents consuming tokens when user is already out of credits
+ */
+declare function canUserAffordApiCall(userId: string, adapter: DAFStorageAdapter): Promise<{
+    allowed: boolean;
+    user: any;
+    message?: string;
+    failureReason?: 'WALLET_DEPLETED' | 'MONTHLY_LIMIT_REACHED';
+}>;
+declare function checkAndUpdateCostLimit(userId: string, costUsed: number, tokensUsed: number, adapter: DAFStorageAdapter, authType?: string): Promise<{
+    allowed: boolean;
+    user: any;
+    message?: string;
+    failureReason?: 'WALLET_DEPLETED' | 'MONTHLY_LIMIT_REACHED';
+}>;
+declare function substituteVariables(text: string, userId: string, adapter: DAFStorageAdapter, processId?: string, parentProcessIds?: string[]): Promise<string>;
+declare function formatActionResult(actionResult: ActionResult): string;
+declare function executeProcess(processId: string, userId: string, adapter: DAFStorageAdapter, modelOverride?: string, scheduleId?: string, authType?: string, editorContext?: boolean): Promise<{
+    success: boolean;
+    runId: any;
+    processId: string;
+}>;
+declare function executeProcessInRun(processId: string, runId: string, userId: string, adapter: DAFStorageAdapter, model?: string, chatResourceIds?: string[]): Promise<void>;
+declare function resumeProcessExecution(runId: string, userId: string, userMessage: string, model: string, adapter: DAFStorageAdapter): Promise<void>;
+
+declare function executeChatTurn(runId: string, userId: string, adapter: DAFStorageAdapter, message: string, model: string, resourceIds: string[], editorContext?: boolean): Promise<void>;
+
+/**
+ * Get OAuth2 client for Google
+ */
+declare function getGoogleOAuth2Client(): google_auth_library.OAuth2Client;
+/**
+ * Generate Google OAuth authorization URL
+ */
+declare function getGoogleAuthUrl(userId: string): string;
+/**
+ * Exchange authorization code for tokens
+ */
+declare function exchangeGoogleCode(code: string): Promise<{
+    accessToken: string;
+    refreshToken: string | null;
+    expiresAt: Date;
+}>;
+/**
+ * Refresh Google access token using refresh token
+ */
+declare function refreshGoogleToken(refreshToken: string): Promise<{
+    accessToken: string;
+    expiresAt: Date;
+}>;
+/**
+ * Get or refresh Google access token for a user
+ */
+declare function getGoogleAccessToken(userId: string, adapter: DAFStorageAdapter): Promise<string>;
+/**
+ * Extract document ID from Google Docs URL
+ */
+declare function extractDocIdFromUrl(url: string): string | null;
+/**
+ * Read content from a Google Doc using Drive API
+ */
+declare function readGoogleDoc(documentId: string, accessToken: string): Promise<{
+    title: string;
+    content: string;
+}>;
+/**
+ * Replace entire content of a Google Doc
+ * Uses Drive API to verify access before writing
+ */
+declare function writeGoogleDoc(documentId: string, content: string, accessToken: string): Promise<void>;
+/**
+ * Selectively replace content in a Google Doc at a specific range
+ */
+declare function selectiveUpdateGoogleDoc(documentId: string, content: string, startIndex: number, endIndex: number, accessToken: string): Promise<void>;
+/**
+ * Append content to a Google Doc
+ */
+declare function appendGoogleDoc(documentId: string, content: string, accessToken: string): Promise<void>;
+/**
+ * Format text in a Google Doc (apply bold, italic, etc.)
+ */
+declare function formatGoogleDoc(documentId: string, startIndex: number, endIndex: number, formatting: {
+    bold?: boolean;
+    italic?: boolean;
+    fontSize?: number;
+}, accessToken: string): Promise<void>;
+/**
+ * Delete a Google Doc (move to trash)
+ */
+declare function deleteGoogleDoc(documentId: string, accessToken: string): Promise<void>;
+/**
+ * Rename a Google Doc
+ */
+declare function renameGoogleDoc(documentId: string, newName: string, accessToken: string): Promise<void>;
+/**
+ * Duplicate a Google Doc
+ */
+declare function duplicateGoogleDoc(documentId: string, newName: string, accessToken: string): Promise<{
+    documentId: string;
+    url: string;
+}>;
+/**
+ * Create a Google Drive folder
+ */
+declare function createGoogleDriveFolder(folderName: string, accessToken: string, parentFolderId?: string): Promise<{
+    folderId: string;
+    url: string;
+}>;
+/**
+ * Extract folder ID from Google Drive folder URL
+ */
+declare function extractFolderIdFromUrl(url: string): string | null;
+/**
+ * Delete a Google Drive folder (move to trash)
+ */
+declare function deleteGoogleDriveFolder(folderId: string, accessToken: string): Promise<void>;
+/**
+ * Rename a Google Drive folder
+ */
+declare function renameGoogleDriveFolder(folderId: string, newName: string, accessToken: string): Promise<void>;
+/**
+ * Create a new Google Doc in a specific folder or root
+ */
+declare function createGoogleDocInFolder(documentName: string, accessToken: string, parentFolderId?: string, initialContent?: string): Promise<{
+    documentId: string;
+    url: string;
+}>;
+/**
+ * List files and folders in a Google Drive folder
+ */
+declare function listGoogleDriveFolderContents(folderId: string, accessToken: string): Promise<Array<{
+    id: string;
+    name: string;
+    type: 'file' | 'folder';
+    mimeType: string;
+    url: string;
+}>>;
+
+/**
+ * Generate Notion OAuth authorization URL
+ * Notion OAuth supports page-level permissions through the authorization flow
+ */
+declare function getNotionAuthUrl(userId: string): string;
+/**
+ * Exchange authorization code for tokens
+ */
+declare function exchangeNotionCode(code: string): Promise<{
+    accessToken: string;
+    workspaceId: string;
+    workspaceName: string;
+    botId: string;
+}>;
+/**
+ * Get Notion access token for a user
+ * Note: Notion tokens don't expire, so no refresh needed
+ */
+declare function getNotionAccessToken(userId: string, adapter: DAFStorageAdapter): Promise<string>;
+/**
+ * Extract page ID from Notion URL
+ */
+declare function extractPageIdFromUrl(url: string): string | null;
+/**
+ * Extract database ID from Notion URL
+ * Database URLs are similar to page URLs but may include view parameter
+ */
+declare function extractDatabaseIdFromUrl(url: string): string | null;
+/**
+ * Get page title from Notion page
+ */
+declare function getNotionPageTitle(pageId: string, accessToken: string): Promise<string | null>;
+/**
+ * Read content from a Notion page
+ */
+declare function readNotionPage(pageId: string, accessToken: string): Promise<string>;
+/**
+ * Replace entire content of a Notion page
+ */
+declare function writeNotionPage(pageId: string, content: string, accessToken: string): Promise<void>;
+/**
+ * Selectively replace blocks in a Notion page by block range
+ * Note: Notion doesn't support character-level indices, so we work with block indices
+ */
+declare function selectiveUpdateNotionPage(pageId: string, content: string, startBlockIndex: number, endBlockIndex: number, accessToken: string): Promise<void>;
+/**
+ * Append content to a Notion page
+ */
+declare function appendNotionPage(pageId: string, content: string, accessToken: string): Promise<void>;
+/**
+ * Delete a Notion page (archive it)
+ */
+declare function deleteNotionPage(pageId: string, accessToken: string): Promise<void>;
+/**
+ * Rename a Notion page by updating its title property
+ */
+declare function renameNotionPage(pageId: string, newTitle: string, accessToken: string): Promise<void>;
+/**
+ * Duplicate a Notion page (creates a new page with the same content)
+ */
+declare function duplicateNotionPage(pageId: string, newTitle: string, accessToken: string): Promise<{
+    pageId: string;
+    url: string;
+}>;
+/**
+ * Create a new Notion page as a subpage of another page or at workspace root
+ */
+declare function createNotionSubpage(parentPageId: string | undefined, pageTitle: string, accessToken: string, initialContent?: string): Promise<{
+    pageId: string;
+    url: string;
+}>;
+/**
+ * List child pages of a Notion page
+ */
+declare function listNotionPageChildren(pageId: string, accessToken: string): Promise<Array<{
+    id: string;
+    title: string;
+    type: 'page' | 'database';
+    url: string;
+}>>;
+/**
+ * Get database title/name and schema
+ */
+declare function getNotionDatabase(databaseId: string, accessToken: string): Promise<{
+    title: string;
+    properties: any;
+}>;
+/**
+ * Create a new page in a Notion database
+ * @param databaseId - The ID of the database to add the page to
+ * @param properties - Object containing property values (e.g., { "Name": "My Page", "Status": "In Progress" })
+ * @param content - Optional markdown content to add to the page body
+ * @param accessToken - Notion access token
+ */
+declare function createNotionDatabasePage(databaseId: string, properties: Record<string, any>, accessToken: string, content?: string): Promise<{
+    pageId: string;
+    url: string;
+}>;
+/**
+ * Query database pages (with optional filters)
+ */
+declare function queryNotionDatabase(databaseId: string, accessToken: string, filter?: any, sorts?: any[]): Promise<any[]>;
+/**
+ * Create a new Notion database
+ * @param parentPageId - The ID of the parent page to create the database in
+ * @param title - The title of the database
+ * @param properties - Database property schema (e.g., { "Name": { title: {} }, "Status": { select: { options: [...] } } })
+ * @param accessToken - Notion access token
+ */
+declare function createNotionDatabase(parentPageId: string | undefined, title: string, properties: Record<string, any>, accessToken: string): Promise<{
+    databaseId: string;
+    url: string;
+}>;
+/**
+ * Read database schema and properties
+ */
+declare function readNotionDatabase(databaseId: string, accessToken: string): Promise<{
+    title: string;
+    properties: Record<string, any>;
+    url: string;
+}>;
+/**
+ * Update database title and/or properties
+ */
+declare function updateNotionDatabase(databaseId: string, accessToken: string, title?: string, properties?: Record<string, any>): Promise<void>;
+/**
+ * Archive/delete a Notion database
+ */
+declare function deleteNotionDatabase(databaseId: string, accessToken: string): Promise<void>;
+/**
+ * Duplicate a Notion database (copies schema but not data/rows)
+ */
+declare function duplicateNotionDatabase(databaseId: string, accessToken: string, newDatabaseName?: string): Promise<{
+    databaseId: string;
+    title: string;
+    url: string;
+}>;
+/**
+ * Update properties and/or content of a database page
+ * @param pageId - The ID of the page to update
+ * @param properties - Optional object containing property values to update
+ * @param content - Optional markdown content to replace the page body
+ * @param accessToken - Notion access token
+ */
+declare function updateNotionDatabasePage(pageId: string, accessToken: string, properties?: Record<string, any>, content?: string): Promise<void>;
+
+export { type Action, type ActionConfig, type ActionResult, type AddDocumentAction, type AddFolderAction, type AskUserInputAction, type CrawlAction, type CreateDatabaseAction, type DAFEmailIntegration, type DAFGoogleIntegration, type DAFNotionIntegration, type DAFProcessRecord, type DAFResourceRecord, type DAFRunRecord, type DAFStorageAdapter, type DAFUserRecord, type DbDeleteAction, type DbFindAction, type DbInsertAction, type DbUpdateAction, type DeleteDatabaseAction, type DuplicateDatabaseAction, type DuplicateDocumentAction, type EditorTransformAction, type ExecutionContext, type FirecrawlActionType, type FormatDocumentAction, GENERIC_VARIABLES, type GenericVariable, type JsonFormatOptions, type LocationSettings, MODEL_PRICING, type NewsSearchAction, type QuickSearchAction, type ReadDatabaseAction, type ReadDocumentAction, type ReadFolderAction, type RemoveDocumentAction, type RemoveFolderAction, type RenameDocumentAction, type RenameFolderAction, type ScrapeAction, type ScrapeFormat, type ScreenshotFormatOptions, type SearchAction, type SendEmailAction, TIER_TOKEN_LIMITS, type TavilySearchAction, type TokenUsage, type UpdateDatabaseAction, type UserProviderSettings, type WebhookConfig, type WriteDatabaseAction, type WriteDocumentAction, appendGoogleDoc, appendNotionPage, buildTokenUsage, calculateTokenCost, canUserAffordApiCall, checkAndUpdateCostLimit, createGoogleDocInFolder, createGoogleDriveFolder, createNotionDatabase, createNotionDatabasePage, createNotionSubpage, deleteGoogleDoc, deleteGoogleDriveFolder, deleteNotionDatabase, deleteNotionPage, duplicateGoogleDoc, duplicateNotionDatabase, duplicateNotionPage, exchangeGoogleCode, exchangeNotionCode, executeAction, executeChatTurn, executeProcess, executeProcessInRun, extractActionsFromMessage, extractDatabaseIdFromUrl, extractDocIdFromUrl, extractFolderIdFromUrl, extractPageIdFromUrl, formatActionResult, formatGoogleDoc, getDescAllActions, getDescChatActions, getDescEditorActions, getGenericVariable, getGenericVariableNames, getGenericVariables, getGoogleAccessToken, getGoogleAuthUrl, getGoogleOAuth2Client, getModelProvider, getNotionAccessToken, getNotionAuthUrl, getNotionDatabase, getNotionPageTitle, getProviderFromModel, isGenericVariable, listGoogleDriveFolderContents, listNotionPageChildren, mergeVariables, processMessageActions, queryNotionDatabase, readGoogleDoc, readNotionDatabase, readNotionPage, refreshGoogleToken, renameGoogleDoc, renameGoogleDriveFolder, renameNotionPage, resumeProcessExecution, selectiveUpdateGoogleDoc, selectiveUpdateNotionPage, substituteVariables, updateNotionDatabase, updateNotionDatabasePage, writeGoogleDoc, writeNotionPage };