@base44-preview/sdk 0.8.17-pr.73.e88f2f7 → 0.8.17-pr.74.aa2810d

package/README.md

@@ -13,7 +13,6 @@ The SDK provides access to Base44's functionality through the following modules:
 - **[`entities`](https://docs.base44.com/sdk-docs/interfaces/entities)**: Work with your app's data entities using CRUD operations.
 - **[`functions`](https://docs.base44.com/sdk-docs/interfaces/functions)**: Execute backend functions.
 - **[`integrations`](https://docs.base44.com/sdk-docs/type-aliases/integrations)**: Pre-built server-side functions for external services.
-- **[`mobile`](#mobile-native-features)**: Send push notifications and access mobile native capabilities.
 
 ## Example
 
@@ -38,135 +37,6 @@ await base44.entities.Task.update(newTask.id, {
 const tasks = await base44.entities.Task.list();
 ```
 
-## Mobile Native Features
-
-The SDK provides mobile native capabilities through the `mobile` module, allowing you to send push notifications to your app users.
-
-### Push Notifications
-
-Send push notifications to users on mobile devices:
-
-```typescript
-import { base44 } from "@/api/base44Client";
-
-// Send a push notification to a user
-await base44.mobile.sendNotification({
-  userId: "user_123",
-  title: "New Message!",
-  content: "You have a new message from John",
-  actionLabel: "View Message",
-  actionUrl: "/messages/456",
-  channels: ["mobile_push"], // Mobile push only
-});
-
-// Send to both mobile push and in-app notifications (default)
-await base44.mobile.sendNotification({
-  userId: "user_456",
-  title: "Order Shipped",
-  content: "Your order #12345 has been shipped and is on its way!",
-  actionLabel: "Track Order",
-  actionUrl: "/orders/12345",
-});
-```
-
-### Notification Channels
-
-The `mobile` module supports two notification channels:
-
-- **`mobile_push`**: Sends a push notification to the user's mobile device (iOS/Android)
-- **`in_app`**: Sends an in-app notification visible in the web interface
-
-By default, notifications are sent to both channels. You can specify specific channels using the `channels` parameter:
-
-```typescript
-// Mobile push only - user will receive push notification on their phone
-await base44.mobile.sendNotification({
-  userId: "user_123",
-  title: "Time-sensitive alert",
-  content: "Your session will expire in 5 minutes",
-  channels: ["mobile_push"],
-});
-
-// In-app only - notification visible only in the web interface
-await base44.mobile.sendNotification({
-  userId: "user_789",
-  title: "System Update",
-  content: "We've updated the dashboard with new features",
-  channels: ["in_app"],
-});
-```
-
-### Common Use Cases
-
-**Order & Delivery Updates**:
-```typescript
-// Notify user when order is ready
-await base44.mobile.sendNotification({
-  userId: order.userId,
-  title: "Order Ready for Pickup",
-  content: `Your order #${order.id} is ready at ${store.name}`,
-  actionLabel: "View Order",
-  actionUrl: `/orders/${order.id}`,
-});
-```
-
-**Chat & Messaging**:
-```typescript
-// Notify user of new messages
-await base44.mobile.sendNotification({
-  userId: recipient.id,
-  title: `New message from ${sender.name}`,
-  content: message.preview,
-  actionLabel: "Reply",
-  actionUrl: `/chats/${conversation.id}`,
-  channels: ["mobile_push"], // Mobile only, avoid duplicate with in-app chat
-});
-```
-
-**Reminders & Events**:
-```typescript
-// Send event reminder
-await base44.mobile.sendNotification({
-  userId: attendee.userId,
-  title: "Event Starting Soon",
-  content: `${event.name} starts in 30 minutes`,
-  actionLabel: "View Details",
-  actionUrl: `/events/${event.id}`,
-});
-```
-
-### Error Handling
-
-The notification API handles errors gracefully:
-
-```typescript
-try {
-  const result = await base44.mobile.sendNotification({
-    userId: "user_123",
-    title: "Test Notification",
-    content: "This is a test",
-  });
-
-  if (result.success) {
-    console.log("Notification sent successfully");
-    console.log("Notification ID:", result.notificationId);
-  }
-} catch (error) {
-  if (error.status === 404) {
-    console.error("User not found");
-  } else if (error.status === 403) {
-    console.error("Not authorized to send notifications");
-  } else {
-    console.error("Failed to send notification:", error.message);
-  }
-}
-```
-
-**Graceful Degradation**:
-- If a user doesn't have mobile push enabled, the notification is still sent to other channels
-- If one channel fails, other channels still receive the notification
-- Notifications are queued and retried automatically for temporary failures
-
 ## Learn more
 
 For complete documentation, guides, and API reference, visit the **[Base44 SDK Documentation](https://docs.base44.com/sdk-getting-started/overview)**.

package/dist/client.js

@@ -9,9 +9,9 @@ import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
 import { createAppLogsModule } from "./modules/app-logs.js";
 import { createUsersModule } from "./modules/users.js";
-import { createMobileModule } from "./modules/mobile.js";
 import { RoomsSocket } from "./utils/socket-utils.js";
 import { createAnalyticsModule } from "./modules/analytics.js";
+import { createRecordingModule } from "./modules/recording.js";
 /**
  * Creates a Base44 client.
  *
@@ -122,13 +122,13 @@ export function createClient(config) {
         }),
         appLogs: createAppLogsModule(axiosClient, appId),
         users: createUsersModule(axiosClient, appId),
-        mobile: createMobileModule(axiosClient, appId),
         analytics: createAnalyticsModule({
             axiosClient,
             serverUrl,
             appId,
             userAuthModule,
         }),
+        recording: createRecordingModule(),
         cleanup: () => {
             userModules.analytics.cleanup();
             if (socket) {
@@ -154,7 +154,6 @@ export function createClient(config) {
             token,
         }),
         appLogs: createAppLogsModule(serviceRoleAxiosClient, appId),
-        mobile: createMobileModule(serviceRoleAxiosClient, appId),
         cleanup: () => {
             if (socket) {
                 socket.disconnect();

package/dist/client.types.d.ts

@@ -6,8 +6,8 @@ import type { ConnectorsModule } from "./modules/connectors.types.js";
 import type { FunctionsModule } from "./modules/functions.types.js";
 import type { AgentsModule } from "./modules/agents.types.js";
 import type { AppLogsModule } from "./modules/app-logs.types.js";
-import type { MobileModule } from "./modules/mobile.types.js";
 import type { AnalyticsModule } from "./modules/analytics.types.js";
+import type { RecordingModule } from "./modules/recording.types.js";
 /**
  * Options for creating a Base44 client.
  */
@@ -84,10 +84,10 @@ export interface Base44Client {
     agents: AgentsModule;
     /** {@link AppLogsModule | App logs module} for tracking app usage. */
     appLogs: AppLogsModule;
-    /** {@link MobileModule | Mobile module} for mobile native capabilities like push notifications. */
-    mobile: MobileModule;
     /** {@link AnalyticsModule | Analytics module} for tracking app usage. */
     analytics: AnalyticsModule;
+    /** {@link RecordingModule | Recording module} for capturing debug sessions. */
+    recording: RecordingModule;
     /** Cleanup function to disconnect WebSocket connections. Call when you're done with the client. */
     cleanup: () => void;
     /**

package/dist/index.d.ts

@@ -10,7 +10,6 @@ export type { IntegrationsModule, IntegrationPackage, IntegrationEndpointFunctio
 export type { FunctionsModule } from "./modules/functions.types.js";
 export type { AgentsModule, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
 export type { AppLogsModule } from "./modules/app-logs.types.js";
-export type { MobileModule, SendNotificationParams, NotificationResult, NotificationChannel, ChannelResult, } from "./modules/mobile.types.js";
 export type { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
 export type { ConnectorsModule } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";

package/dist/modules/recording.d.ts

@@ -0,0 +1,8 @@
+import type { RecordingModule } from "./recording.types.js";
+/**
+ * Creates the recording module for the Base44 SDK.
+ *
+ * @returns Recording module with methods for capturing debug sessions
+ * @internal
+ */
+export declare function createRecordingModule(): RecordingModule;

package/dist/modules/recording.js

@@ -0,0 +1,266 @@
+import { record, IncrementalSource, MouseInteractions, } from "rrweb";
+import { getRecordConsolePlugin } from "@rrweb/rrweb-plugin-console-record";
+import { generateUuid } from "../utils/common.js";
+const state = {
+    isRecording: false,
+    sessionId: null,
+    startTime: null,
+    events: [],
+    stopFn: null,
+};
+/**
+ * Creates the recording module for the Base44 SDK.
+ *
+ * @returns Recording module with methods for capturing debug sessions
+ * @internal
+ */
+export function createRecordingModule() {
+    return {
+        start() {
+            if (state.isRecording) {
+                throw new Error("Recording is already in progress");
+            }
+            if (typeof window === "undefined") {
+                throw new Error("Recording is only available in browser environments");
+            }
+            // Reset state
+            state.isRecording = true;
+            state.sessionId = generateUuid();
+            state.startTime = new Date().toISOString();
+            state.events = [];
+            const stopFn = record({
+                emit: (event) => {
+                    state.events.push(event);
+                },
+                plugins: [
+                    getRecordConsolePlugin({
+                        level: ["log", "warn", "error", "info", "debug"],
+                        lengthThreshold: 10000,
+                        stringifyOptions: {
+                            stringLengthLimit: 5000,
+                            numOfKeysLimit: 100,
+                            depthOfLimit: 5,
+                        },
+                    }),
+                ],
+            });
+            state.stopFn = stopFn !== null && stopFn !== void 0 ? stopFn : null;
+        },
+        stop() {
+            if (!state.isRecording) {
+                throw new Error("No recording is in progress");
+            }
+            // Stop rrweb recording
+            if (state.stopFn) {
+                state.stopFn();
+                state.stopFn = null;
+            }
+            const endTime = new Date().toISOString();
+            const startTime = state.startTime;
+            const duration = new Date(endTime).getTime() - new Date(startTime).getTime();
+            // Extract data from events
+            const consoleEntries = extractConsoleEntries(state.events);
+            const userActions = extractUserActions(state.events);
+            const report = {
+                sessionId: state.sessionId,
+                startTime,
+                endTime,
+                duration,
+                console: consoleEntries,
+                userActions,
+            };
+            // Reset state
+            state.isRecording = false;
+            state.sessionId = null;
+            state.startTime = null;
+            state.events = [];
+            return report;
+        },
+        isRecording() {
+            return state.isRecording;
+        },
+        toText(report) {
+            const lines = [
+                "## Debug Session Report",
+                `Session ID: ${report.sessionId}`,
+                `Duration: ${report.duration}ms`,
+                `Recorded: ${report.startTime} to ${report.endTime}`,
+                "",
+                `### User Actions (${report.userActions.length} actions)`,
+            ];
+            if (report.userActions.length === 0) {
+                lines.push("No user actions captured.");
+            }
+            else {
+                for (const action of report.userActions) {
+                    const timestamp = new Date(action.timestamp).toISOString();
+                    const valueStr = action.value ? ` = "${action.value}"` : "";
+                    lines.push(`[${timestamp}] ${action.type}: ${action.target}${valueStr}`);
+                }
+            }
+            lines.push("");
+            lines.push(`### Console Output (${report.console.length} entries)`);
+            if (report.console.length === 0) {
+                lines.push("No console output captured.");
+            }
+            else {
+                for (const entry of report.console) {
+                    const timestamp = new Date(entry.timestamp).toISOString();
+                    lines.push(`[${timestamp}] [${entry.level.toUpperCase()}] ${entry.message}`);
+                }
+            }
+            return lines.join("\n");
+        },
+    };
+}
+/**
+ * Extracts console entries from rrweb events.
+ */
+function extractConsoleEntries(events) {
+    var _a;
+    const consoleEntries = [];
+    for (const event of events) {
+        // rrweb plugin events have type 6
+        if (event.type === 6 && ((_a = event.data) === null || _a === void 0 ? void 0 : _a.plugin) === "rrweb/console@1") {
+            const payload = event.data.payload;
+            if (payload && payload.level && payload.payload) {
+                const message = stringifyConsolePayload(payload.payload);
+                consoleEntries.push({
+                    level: payload.level,
+                    message,
+                    timestamp: event.timestamp,
+                });
+            }
+        }
+    }
+    return consoleEntries;
+}
+/**
+ * Converts console payload array to a readable string.
+ */
+function stringifyConsolePayload(payload) {
+    return payload
+        .map((item) => {
+        if (typeof item === "string") {
+            return item;
+        }
+        try {
+            return JSON.stringify(item);
+        }
+        catch (_a) {
+            return String(item);
+        }
+    })
+        .join(" ");
+}
+/**
+ * Extracts user actions from rrweb events.
+ */
+function extractUserActions(events) {
+    const userActions = [];
+    // Build a map of node IDs to readable descriptions from the full snapshot
+    const nodeMap = buildNodeMap(events);
+    for (const event of events) {
+        // IncrementalSnapshot events have type 3
+        if (event.type !== 3 || !event.data)
+            continue;
+        const { source, type, id, text } = event.data;
+        // Mouse interactions
+        if (source === IncrementalSource.MouseInteraction && id !== undefined) {
+            const actionType = getMouseInteractionType(type);
+            if (actionType) {
+                userActions.push({
+                    type: actionType,
+                    target: nodeMap.get(id) || `element#${id}`,
+                    timestamp: event.timestamp,
+                });
+            }
+        }
+        // Input events
+        if (source === IncrementalSource.Input && id !== undefined) {
+            userActions.push({
+                type: "input",
+                target: nodeMap.get(id) || `input#${id}`,
+                value: text ? truncateString(text, 100) : undefined,
+                timestamp: event.timestamp,
+            });
+        }
+    }
+    return userActions;
+}
+/**
+ * Maps mouse interaction type number to readable action type.
+ */
+function getMouseInteractionType(type) {
+    switch (type) {
+        case MouseInteractions.Click:
+            return "click";
+        case MouseInteractions.DblClick:
+            return "dblclick";
+        default:
+            return null;
+    }
+}
+/**
+ * Builds a map of node IDs to readable descriptions from the full snapshot.
+ */
+function buildNodeMap(events) {
+    var _a;
+    const nodeMap = new Map();
+    // Find the full snapshot (type 2)
+    const fullSnapshot = events.find((e) => e.type === 2);
+    if (!fullSnapshot)
+        return nodeMap;
+    // Recursively extract node info
+    const extractNodes = (node) => {
+        if (!node || typeof node !== "object")
+            return;
+        if (node.id !== undefined && node.tagName) {
+            const parts = [`<${node.tagName.toLowerCase()}`];
+            if (node.attributes) {
+                if (node.attributes.id) {
+                    parts[0] += `#${node.attributes.id}`;
+                }
+                if (node.attributes.class) {
+                    const firstClass = node.attributes.class.split(" ")[0];
+                    if (firstClass)
+                        parts[0] += `.${firstClass}`;
+                }
+            }
+            parts[0] += ">";
+            // Add text content hint if available
+            if (node.childNodes) {
+                for (const child of node.childNodes) {
+                    if (child.type === 3 && child.textContent) {
+                        // Text node
+                        const text = child.textContent.trim().slice(0, 30);
+                        if (text) {
+                            parts.push(`"${text}"`);
+                            break;
+                        }
+                    }
+                }
+            }
+            nodeMap.set(node.id, parts.join(" "));
+        }
+        // Recurse into children
+        if (node.childNodes) {
+            for (const child of node.childNodes) {
+                extractNodes(child);
+            }
+        }
+    };
+    // Start from the snapshot data
+    if ((_a = fullSnapshot.data) === null || _a === void 0 ? void 0 : _a.node) {
+        extractNodes(fullSnapshot.data.node);
+    }
+    return nodeMap;
+}
+/**
+ * Truncates a string to a maximum length.
+ */
+function truncateString(str, maxLength) {
+    if (str.length <= maxLength)
+        return str;
+    return str.slice(0, maxLength - 3) + "...";
+}

package/dist/modules/recording.types.d.ts

@@ -0,0 +1,118 @@
+/**
+ * A console log entry captured during recording.
+ */
+export interface ConsoleEntry {
+    /** The console method that was called. */
+    level: "log" | "warn" | "error" | "info" | "debug";
+    /** The logged message content. */
+    message: string;
+    /** Unix timestamp when the log occurred. */
+    timestamp: number;
+}
+/**
+ * A user action captured during recording.
+ */
+export interface UserAction {
+    /** The type of interaction. */
+    type: "click" | "dblclick" | "input";
+    /** Description of the target element. */
+    target: string;
+    /** Value entered (for input actions). */
+    value?: string;
+    /** Unix timestamp when the action occurred. */
+    timestamp: number;
+}
+/**
+ * Debug report containing captured session data.
+ */
+export interface DebugReport {
+    /** Unique session identifier. */
+    sessionId: string;
+    /** Recording start time (ISO 8601). */
+    startTime: string;
+    /** Recording end time (ISO 8601). */
+    endTime: string;
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Captured console output. */
+    console: ConsoleEntry[];
+    /** Captured user actions (clicks, inputs, etc.). */
+    userActions: UserAction[];
+}
+/**
+ * Recording module for capturing debug sessions.
+ *
+ * This module captures console output from the running app to help debug issues.
+ * It's designed to provide context for AI agents analyzing app problems.
+ *
+ * @example
+ * ```typescript
+ * // Start recording
+ * base44.recording.start();
+ *
+ * // ... user reproduces the issue ...
+ *
+ * // Stop and get the report
+ * const report = base44.recording.stop();
+ * console.log(report.console); // All console output
+ *
+ * // Get text summary for LLM
+ * const summary = base44.recording.toText(report);
+ * ```
+ */
+export interface RecordingModule {
+    /**
+     * Starts a debug recording session.
+     *
+     * Captures console output until stopped.
+     * Only one recording can be active at a time.
+     *
+     * @throws {Error} If a recording is already in progress.
+     *
+     * @example
+     * ```typescript
+     * base44.recording.start();
+     * ```
+     */
+    start(): void;
+    /**
+     * Stops the current recording and returns the captured data.
+     *
+     * @returns The debug report containing all captured console output.
+     * @throws {Error} If no recording is in progress.
+     *
+     * @example
+     * ```typescript
+     * const report = base44.recording.stop();
+     * console.log(`Captured ${report.console.length} console entries`);
+     * ```
+     */
+    stop(): DebugReport;
+    /**
+     * Checks if a recording is currently in progress.
+     *
+     * @returns True if recording, false otherwise.
+     *
+     * @example
+     * ```typescript
+     * if (!base44.recording.isRecording()) {
+     *   base44.recording.start();
+     * }
+     * ```
+     */
+    isRecording(): boolean;
+    /**
+     * Generates a text summary of a debug report for LLM consumption.
+     *
+     * @param report - The debug report to summarize.
+     * @returns A formatted text summary.
+     *
+     * @example
+     * ```typescript
+     * const report = base44.recording.stop();
+     * const summary = base44.recording.toText(report);
+     * // Send summary to your backend for LLM processing
+     * ```
+     */
+    toText(report: DebugReport): string;
+}

package/dist/modules/recording.types.js

@@ -0,0 +1 @@
+export {};

package/dist/modules/types.d.ts

@@ -2,3 +2,4 @@ export * from "./app.types.js";
 export * from "./agents.types.js";
 export * from "./connectors.types.js";
 export * from "./analytics.types.js";
+export * from "./recording.types.js";

package/dist/modules/types.js

@@ -2,3 +2,4 @@ export * from "./app.types.js";
 export * from "./agents.types.js";
 export * from "./connectors.types.js";
 export * from "./analytics.types.js";
+export * from "./recording.types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44-preview/sdk",
-  "version": "0.8.17-pr.73.e88f2f7",
+  "version": "0.8.17-pr.74.aa2810d",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,7 +24,9 @@
     "create-docs:process": "node scripts/mintlify-post-processing/file-processing/file-processing.js"
   },
   "dependencies": {
+    "@rrweb/rrweb-plugin-console-record": "^2.0.0-alpha.18",
     "axios": "^1.6.2",
+    "rrweb": "^2.0.0-alpha.18",
     "socket.io-client": "^4.7.5",
     "uuid": "^13.0.0"
   },

package/dist/modules/mobile.d.ts

@@ -1,16 +0,0 @@
-/**
- * Mobile module for Base44 SDK.
- *
- * Provides mobile native capabilities like push notifications.
- */
-import { AxiosInstance } from "axios";
-import { MobileModule } from "./mobile.types";
-/**
- * Creates the mobile module for the Base44 SDK.
- *
- * @param axios - Axios instance for API requests
- * @param appId - Application ID
- * @returns Mobile module with native mobile capabilities
- * @internal
- */
-export declare function createMobileModule(axios: AxiosInstance, appId: string): MobileModule;

package/dist/modules/mobile.js

@@ -1,39 +0,0 @@
-/**
- * Mobile module for Base44 SDK.
- *
- * Provides mobile native capabilities like push notifications.
- */
-/**
- * Validates notification parameters against character limits.
- * @param params - Notification parameters to validate
- * @throws Error if any parameter exceeds its limit
- */
-function validateNotificationParams(params) {
-    if (params.title.length > 100) {
-        throw new Error(`Title must be 100 characters or less (current: ${params.title.length})`);
-    }
-    if (params.content.length > 500) {
-        throw new Error(`Content must be 500 characters or less (current: ${params.content.length})`);
-    }
-    if (params.actionLabel && params.actionLabel.length > 50) {
-        throw new Error(`Action label must be 50 characters or less (current: ${params.actionLabel.length})`);
-    }
-}
-/**
- * Creates the mobile module for the Base44 SDK.
- *
- * @param axios - Axios instance for API requests
- * @param appId - Application ID
- * @returns Mobile module with native mobile capabilities
- * @internal
- */
-export function createMobileModule(axios, appId) {
-    return {
-        async sendNotification(params) {
-            // Validate input parameters
-            validateNotificationParams(params);
-            const response = await axios.post(`/api/apps/${appId}/mobile/notifications`, params);
-            return response.data;
-        },
-    };
-}

package/dist/modules/mobile.types.d.ts

@@ -1,86 +0,0 @@
-/**
- * TypeScript type definitions for Base44 Mobile SDK.
- *
- * Provides mobile native capabilities like push notifications
- * for apps built with Base44.
- */
-/**
- * Channel type for notifications.
- * - "mobile_push": Send via mobile push notification (Ping service)
- * - "in_app": Send via in-app notification (WebSocket + MongoDB)
- */
-export type NotificationChannel = "mobile_push" | "in_app";
-/**
- * Parameters for sending a notification to an app user.
- */
-export interface SendNotificationParams {
-    /** App user ID to notify */
-    userId: string;
-    /** Notification title (max 100 characters) */
-    title: string;
-    /** Notification content (max 500 characters, supports HTML) */
-    content: string;
-    /** Optional button text (max 50 characters) */
-    actionLabel?: string;
-    /** Optional button link */
-    actionUrl?: string;
-    /** Optional list of channels. If not specified, uses all channels (mobile_push + in_app) */
-    channels?: NotificationChannel[];
-    /** Optional custom metadata */
-    metadata?: Record<string, unknown>;
-}
-/**
- * Result from a single notification channel.
- */
-export interface ChannelResult {
-    /** Whether the notification was sent successfully through this channel */
-    success: boolean;
-    /** Error message if the channel failed */
-    error?: string;
-}
-/**
- * Response from sending a notification.
- */
-export interface NotificationResult {
-    /** Overall success status */
-    success: boolean;
-    /** Notification ID if in_app channel was used */
-    notificationId?: string;
-    /** Results per channel */
-    channels: {
-        in_app?: ChannelResult;
-        mobile_push?: ChannelResult;
-    };
-}
-/**
- * Mobile module interface providing mobile native capabilities.
- */
-export interface MobileModule {
-    /**
-     * Send a notification to an app user.
-     *
-     * @param params - Notification parameters
-     * @returns Promise resolving to notification result
-     *
-     * @example
-     * ```typescript
-     * // Send mobile push notification only
-     * await base44.mobile.sendNotification({
-     *   userId: 'app_user_123',
-     *   title: 'New Message!',
-     *   content: 'You have a new message from John',
-     *   actionLabel: 'View Message',
-     *   actionUrl: '/messages/456',
-     *   channels: ['mobile_push']
-     * });
-     *
-     * // Send to both channels (default)
-     * await base44.mobile.sendNotification({
-     *   userId: 'app_user_123',
-     *   title: 'Order Shipped',
-     *   content: 'Your order #12345 has been shipped'
-     * });
-     * ```
-     */
-    sendNotification(params: SendNotificationParams): Promise<NotificationResult>;
-}

package/dist/modules/mobile.types.js

@@ -1,7 +0,0 @@
-/**
- * TypeScript type definitions for Base44 Mobile SDK.
- *
- * Provides mobile native capabilities like push notifications
- * for apps built with Base44.
- */
-export {};