@base44-preview/sdk 0.8.5-pr.52.f01053f → 0.8.6-pr.48.9e4e306

package/dist/client.types.d.ts

@@ -0,0 +1,131 @@
+import type { EntitiesModule } from "./modules/entities.types.js";
+import type { IntegrationsModule } from "./modules/integrations.types.js";
+import type { AuthModule } from "./modules/auth.types.js";
+import type { SsoModule } from "./modules/sso.types.js";
+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";
+/**
+ * Options for creating a Base44 client.
+ */
+export interface CreateClientOptions {
+    /**
+     * Optional error handler that will be called whenever an API error occurs.
+     */
+    onError?: (error: Error) => void;
+}
+/**
+ * Configuration for creating a Base44 client.
+ */
+export interface CreateClientConfig {
+    /**
+     * The Base44 server URL. Defaults to "https://base44.app".
+     * @internal
+     */
+    serverUrl?: string;
+    /**
+     * The base URL of the app, which is used for login redirects.
+     * @internal
+     */
+    appBaseUrl?: string;
+    /**
+     * The Base44 app ID.
+     *
+     * You can find the `appId` in the browser URL when you're in the app editor.
+     * It's the string between `/apps/` and `/editor/`.
+     */
+    appId: string;
+    /**
+     * User authentication token. Used to authenticate as a specific user.
+     */
+    token?: string;
+    /**
+     * Service role authentication token. Use this in the backend when you need elevated permissions to access data available to the app's admin or perform admin operations. This token should be kept secret and never exposed in the app's frontend. Typically, you get this token from a request to a backend function using {@linkcode createClientFromRequest | createClientFromRequest()}.
+     */
+    serviceToken?: string;
+    /**
+     * Whether authentication is required. If true, redirects to login if not authenticated.
+     * @internal
+     */
+    requiresAuth?: boolean;
+    /**
+     * Version string for functions API.
+     * @internal
+     */
+    functionsVersion?: string;
+    /**
+     * Additional headers to include in API requests.
+     * @internal
+     */
+    headers?: Record<string, string>;
+    /**
+     * Additional client options.
+     */
+    options?: CreateClientOptions;
+}
+/**
+ * The Base44 client instance.
+ *
+ * Provides access to all SDK modules for interacting with the app.
+ */
+export interface Base44Client {
+    /** {@link EntitiesModule | Entities module} for CRUD operations on your data models. */
+    entities: EntitiesModule;
+    /** {@link IntegrationsModule | Integrations module} for calling pre-built integration endpoints. */
+    integrations: IntegrationsModule;
+    /** {@link AuthModule | Auth module} for user authentication and management. */
+    auth: AuthModule;
+    /** {@link FunctionsModule | Functions module} for invoking custom backend functions. */
+    functions: FunctionsModule;
+    /** {@link AgentsModule | Agents module} for managing AI agent conversations. */
+    agents: AgentsModule;
+    /** {@link AppLogsModule | App logs module} for tracking app usage. */
+    appLogs: AppLogsModule;
+    /** Cleanup function to disconnect WebSocket connections. Call when you're done with the client. */
+    cleanup: () => void;
+    /**
+     * Sets a new authentication token for all subsequent requests.
+     *
+     * Updates the token for both HTTP requests and WebSocket connections.
+     *
+     * @param newToken - The new authentication token.
+     */
+    setToken(newToken: string): void;
+    /**
+     * Gets the current client configuration.
+     * @internal
+     */
+    getConfig(): {
+        serverUrl: string;
+        appId: string;
+        requiresAuth: boolean;
+    };
+    /**
+     * Provides access to supported modules with elevated permissions.
+     *
+     * Service role authentication provides elevated permissions for backend operations. Unlike user authentication, which is scoped to a specific user's permissions, service role authentication has access to the data and operations available to the app's admin.
+     *
+     * @throws {Error} When accessed without providing a serviceToken during client creation
+     */
+    readonly asServiceRole: {
+        /** {@link EntitiesModule | Entities module} with elevated permissions. */
+        entities: EntitiesModule;
+        /** {@link IntegrationsModule | Integrations module} with elevated permissions. */
+        integrations: IntegrationsModule;
+        /** {@link SsoModule | SSO module} for generating SSO tokens.
+         * @internal
+         */
+        sso: SsoModule;
+        /** {@link ConnectorsModule | Connectors module} for OAuth token retrieval. */
+        connectors: ConnectorsModule;
+        /** {@link FunctionsModule | Functions module} with elevated permissions. */
+        functions: FunctionsModule;
+        /** {@link AgentsModule | Agents module} with elevated permissions. */
+        agents: AgentsModule;
+        /** {@link AppLogsModule | App logs module} with elevated permissions. */
+        appLogs: AppLogsModule;
+        /** Cleanup function to disconnect WebSocket connections. */
+        cleanup: () => void;
+    };
+}

package/dist/client.types.js

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

package/dist/index.d.ts

@@ -1,7 +1,15 @@
-import { createClient, createClientFromRequest, type Base44Client } from "./client.js";
-import { Base44Error } from "./utils/axios-client.js";
+import { createClient, createClientFromRequest, type Base44Client, type CreateClientConfig, type CreateClientOptions } from "./client.js";
+import { Base44Error, type Base44ErrorJSON } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from "./utils/auth-utils.js";
-import { appParams } from "./utils/app-params.js";
-export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, appParams };
-export type { Base44Client };
+export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
+export type { Base44Client, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
+export type { EntitiesModule, EntityHandler, } from "./modules/entities.types.js";
+export type { AuthModule, LoginResponse, RegisterParams, VerifyOtpParams, ChangePasswordParams, ResetPasswordParams, User, } from "./modules/auth.types.js";
+export type { IntegrationsModule, IntegrationPackage, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
+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 { SsoModule, SsoAccessTokenResponse } from "./modules/sso.types.js";
+export type { ConnectorsModule } from "./modules/connectors.types.js";
+export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

package/dist/index.js

@@ -1,6 +1,5 @@
-import { createClient, createClientFromRequest } from "./client.js";
+import { createClient, createClientFromRequest, } from "./client.js";
 import { Base44Error } from "./utils/axios-client.js";
 import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, } from "./utils/auth-utils.js";
-import { appParams } from "./utils/app-params.js";
-export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, appParams };
+export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export * from "./types.js";

package/dist/modules/agents.d.ts

@@ -1,23 +1,2 @@
-import { RoomsSocket } from "../utils/socket-utils.js";
-import { AgentConversation, AgentMessage } from "./agents.types.js";
-import { AxiosInstance } from "axios";
-import { ModelFilterParams } from "../types.js";
-export type AgentsModuleConfig = {
-    axios: AxiosInstance;
-    socket: ReturnType<typeof RoomsSocket>;
-    appId: string;
-    serverUrl?: string;
-    token?: string;
-};
-export declare function createAgentsModule({ axios, socket, appId, serverUrl, token, }: AgentsModuleConfig): {
-    getConversations: () => Promise<AgentConversation[]>;
-    getConversation: (conversationId: string) => Promise<AgentConversation | undefined>;
-    listConversations: (filterParams: ModelFilterParams) => Promise<AgentConversation[]>;
-    createConversation: (conversation: {
-        agent_name: string;
-        metadata?: Record<string, any>;
-    }) => Promise<AgentConversation>;
-    addMessage: (conversation: AgentConversation, message: AgentMessage) => Promise<AgentMessage>;
-    subscribeToConversation: (conversationId: string, onUpdate?: (conversation: AgentConversation) => void) => () => void;
-    getWhatsAppConnectURL: (agentName: string) => string;
-};
+import { AgentsModule, AgentsModuleConfig } from "./agents.types.js";
+export declare function createAgentsModule({ axios, getSocket, appId, serverUrl, token, }: AgentsModuleConfig): AgentsModule;

package/dist/modules/agents.js

@@ -1,5 +1,5 @@
 import { getAccessToken } from "../utils/auth-utils.js";
-export function createAgentsModule({ axios, socket, appId, serverUrl, token, }) {
+export function createAgentsModule({ axios, getSocket, appId, serverUrl, token, }) {
     const baseURL = `/apps/${appId}/agents`;
     const getConversations = () => {
         return axios.get(`${baseURL}/conversations`);
@@ -17,6 +17,7 @@ export function createAgentsModule({ axios, socket, appId, serverUrl, token, })
     };
     const addMessage = async (conversation, message) => {
         const room = `/agent-conversations/${conversation.id}`;
+        const socket = getSocket();
         await socket.updateModel(room, {
             ...conversation,
             messages: [...(conversation.messages || []), message],
@@ -25,6 +26,7 @@ export function createAgentsModule({ axios, socket, appId, serverUrl, token, })
     };
     const subscribeToConversation = (conversationId, onUpdate) => {
         const room = `/agent-conversations/${conversationId}`;
+        const socket = getSocket();
         return socket.subscribeToRoom(room, {
             connect: () => { },
             update_model: ({ data: jsonStr }) => {

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

@@ -1,44 +1,340 @@
-export type AgentConversation = {
+import { AxiosInstance } from "axios";
+import { RoomsSocket } from "../utils/socket-utils";
+import { ModelFilterParams } from "../types";
+/**
+ * Reasoning information for an agent message.
+ *
+ * Contains details about the agent's reasoning process when generating a response.
+ */
+export interface AgentMessageReasoning {
+    /** When reasoning started. */
+    start_date: string;
+    /** When reasoning ended. */
+    end_date?: string;
+    /** Reasoning content. */
+    content: string;
+}
+/**
+ * A tool call made by the agent.
+ *
+ * Represents a function or tool that the agent invoked during message generation.
+ */
+export interface AgentMessageToolCall {
+    /** Tool call ID. */
     id: string;
+    /** Name of the tool called. */
+    name: string;
+    /** Arguments passed to the tool as JSON string. */
+    arguments_string: string;
+    /** Status of the tool call. */
+    status: "running" | "success" | "error" | "stopped";
+    /** Results from the tool call. */
+    results?: string;
+}
+/**
+ * Token usage statistics for an agent message.
+ *
+ * Tracks the number of tokens consumed when generating the message.
+ */
+export interface AgentMessageUsage {
+    /** Number of tokens in the prompt. */
+    prompt_tokens?: number;
+    /** Number of tokens in the completion. */
+    completion_tokens?: number;
+}
+/**
+ * Custom context provided with an agent message.
+ *
+ * Additional contextual information that can be passed to the agent.
+ */
+export interface AgentMessageCustomContext {
+    /** Context message. */
+    message: string;
+    /** Associated data for the context. */
+    data: Record<string, any>;
+    /** Type of context. */
+    type: string;
+}
+/**
+ * Metadata about when and by whom a message was created.
+ */
+export interface AgentMessageMetadata {
+    /** When the message was created. */
+    created_date: string;
+    /** Email of the user who created the message. */
+    created_by_email: string;
+    /** Full name of the user who created the message. */
+    created_by_full_name: string;
+}
+/**
+ * An agent conversation containing messages exchanged with an AI agent.
+ */
+export interface AgentConversation {
+    /** Unique identifier for the conversation. */
+    id: string;
+    /** Application ID. */
     app_id: string;
+    /** Name of the agent in this conversation. */
     agent_name: string;
+    /** ID of the user who created the conversation. */
     created_by_id: string;
+    /** When the conversation was created. */
+    created_date: string;
+    /** When the conversation was last updated. */
+    updated_date: string;
+    /** Array of messages in the conversation. */
     messages: AgentMessage[];
+    /** Optional metadata associated with the conversation. */
     metadata?: Record<string, any>;
-};
-export type AgentMessage = {
+}
+/**
+ * A message in an agent conversation.
+ */
+export interface AgentMessage {
+    /** Unique identifier for the message. */
     id: string;
+    /** Role of the message sender. */
     role: "user" | "assistant" | "system";
-    reasoning?: {
-        start_date: string;
-        end_date?: string;
-        content: string;
-    };
-    content?: string | Record<string, any> | null;
-    file_urls?: string[] | null;
-    tool_calls?: {
-        id: string;
-        name: string;
-        arguments_string: string;
-        status: "running" | "success" | "error" | "stopped";
-        results?: string | null;
-    }[] | null;
-    usage?: {
-        prompt_tokens?: number;
-        completion_tokens?: number;
-    } | null;
+    /** When the message was created. */
+    created_date: string;
+    /** When the message was last updated. */
+    updated_date: string;
+    /** Optional reasoning information for the message. */
+    reasoning?: AgentMessageReasoning | null;
+    /** Message content. */
+    content?: string | Record<string, any>;
+    /** URLs to files attached to the message. */
+    file_urls?: string[];
+    /** Tool calls made by the agent. */
+    tool_calls?: AgentMessageToolCall[];
+    /** Token usage statistics. */
+    usage?: AgentMessageUsage;
+    /** Whether the message is hidden from the user. */
     hidden?: boolean;
-    custom_context?: {
-        message: string;
-        data: Record<string, any>;
-        type: string;
-    }[] | null;
-    model?: string | null;
-    checkpoint_id?: string | null;
-    metadata?: {
-        created_date: string;
-        created_by_email: string;
-        created_by_full_name: string | null;
-    };
+    /** Custom context provided with the message. */
+    custom_context?: AgentMessageCustomContext[];
+    /** Model used to generate the message. */
+    model?: string;
+    /** Checkpoint ID for the message. */
+    checkpoint_id?: string;
+    /** Metadata about when and by whom the message was created. */
+    metadata?: AgentMessageMetadata;
+    /** Additional custom parameters for the message. */
     additional_message_params?: Record<string, any>;
-};
+}
+/**
+ * Parameters for creating a new conversation.
+ */
+export interface CreateConversationParams {
+    /** The name of the agent to create a conversation with. */
+    agent_name: string;
+    /** Optional metadata to attach to the conversation. */
+    metadata?: Record<string, any>;
+}
+/**
+ * Configuration for creating the agents module.
+ * @internal
+ */
+export interface AgentsModuleConfig {
+    /** Axios instance for HTTP requests */
+    axios: AxiosInstance;
+    /** Function to get WebSocket instance for real-time updates (lazy initialization) */
+    getSocket: () => ReturnType<typeof RoomsSocket>;
+    /** Application ID */
+    appId: string;
+    /** Server URL */
+    serverUrl?: string;
+    /** Authentication token */
+    token?: string;
+}
+/**
+ * Agents module for managing AI agent conversations.
+ *
+ * This module provides methods to create and manage conversations with AI agents,
+ * send messages, and subscribe to real-time updates. Conversations can be used
+ * for chat interfaces, support systems, or any interactive AI app.
+ *
+ * The agents module enables you to:
+ *
+ * - **Create conversations** with agents defined in the app.
+ * - **Send messages** from users to agents and receive AI-generated responses.
+ * - **Retrieve conversations** individually or as filtered lists with sorting and pagination.
+ * - **Subscribe to real-time updates** using WebSocket connections to receive instant notifications when new messages arrive.
+ * - **Attach metadata** to conversations for tracking context, categories, priorities, or linking to external systems.
+ * - **Generate WhatsApp connection URLs** for users to interact with agents through WhatsApp.
+ *
+ * The agents module operates with a two-level hierarchy:
+ *
+ * 1. **Conversations**: Top-level containers that represent a dialogue with a specific agent. Each conversation has a unique ID, is associated with an agent by name, and belongs to the user who created it. Conversations can include optional metadata for tracking app-specific context like ticket IDs, categories, or custom fields.
+ *
+ * 2. **Messages**: Individual exchanges within a conversation. Each message has a role, content, and optional metadata like token usage, tool calls, file attachments, and reasoning information. Messages are stored as an array within their parent conversation.
+ *
+ * This module is available to use with a client in all authentication modes:
+ *
+ * - **Anonymous or User authentication** (`base44.agents`): Access is scoped to the current user's permissions. Anonymous users can create conversations but can't retrieve them later, while authenticated users can access conversations they created.
+ * - **Service role authentication** (`base44.asServiceRole.agents`): Operations have elevated admin-level permissions. Can access all conversations that the app's admin role has access to.
+ *
+ */
+export interface AgentsModule {
+    /**
+     * Gets all conversations from all agents in the app.
+     *
+     * Retrieves all conversations. Use {@linkcode listConversations | listConversations()} to filter which conversations are returned, apply sorting, or paginate results. Use {@linkcode getConversation | getConversation()} to retrieve a specific conversation by ID.
+     *
+     * @returns Promise resolving to an array of conversations.
+     *
+     * @example
+     * ```typescript
+     * // Get all conversations
+     * const conversations = await base44.agents.getConversations();
+     * console.log(`Total conversations: ${conversations.length}`);
+     * ```
+     *
+     * @see {@linkcode listConversations | listConversations()} for filtering, sorting, and pagination
+     * @see {@linkcode getConversation | getConversation()} for retrieving a specific conversation by ID
+     */
+    getConversations(): Promise<AgentConversation[]>;
+    /**
+     * Gets a specific conversation by ID.
+     *
+     * Retrieves a single conversation using its unique identifier. To retrieve
+     * all conversations, use {@linkcode getConversations | getConversations()} To filter, sort, or paginate conversations, use {@linkcode listConversations | listConversations()}.
+     *
+     * @param conversationId - The unique identifier of the conversation.
+     * @returns Promise resolving to the conversation, or undefined if not found.
+     *
+     * @example
+     * ```typescript
+     * // Get a specific conversation by ID
+     * const conversation = await base44.agents.getConversation('conv-123');
+     * if (conversation) {
+     *   console.log(`Conversation has ${conversation.messages.length} messages`);
+     * }
+     * ```
+     *
+     * @see {@linkcode getConversations | getConversations()} for retrieving all conversations
+     * @see {@linkcode listConversations | listConversations()} for filtering and sorting conversations
+     */
+    getConversation(conversationId: string): Promise<AgentConversation | undefined>;
+    /**
+     * Lists conversations with filtering, sorting, and pagination.
+     *
+     * Provides querying capabilities including filtering by fields, sorting, pagination, and field selection. For cases where you need all conversations without filtering, use {@linkcode getConversations | getConversations()}. To retrieve a specific conversation by ID, use {@linkcode getConversation | getConversation()}.
+     *
+     * @param filterParams - Filter parameters for querying conversations.
+     * @returns Promise resolving to an array of filtered conversations.
+     *
+     * @example
+     * ```typescript
+     * // List recent conversations with pagination
+     * const recentConversations = await base44.agents.listConversations({
+     *   limit: 10,
+     *   sort: '-created_date'
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Filter by agent and metadata
+     * const supportConversations = await base44.agents.listConversations({
+     *   q: {
+     *     agent_name: 'support-agent',
+     *     'metadata.priority': 'high'
+     *   },
+     *   sort: '-created_date',
+     *   limit: 20
+     * });
+     * ```
+     *
+     * @see {@linkcode getConversations | getConversations()} for retrieving all conversations without filtering
+     * @see {@linkcode getConversation | getConversation()} for retrieving a specific conversation by ID
+     */
+    listConversations(filterParams: ModelFilterParams): Promise<AgentConversation[]>;
+    /**
+     * Creates a new conversation with an agent.
+     *
+     * @param conversation - Conversation details including agent name and optional metadata.
+     * @returns Promise resolving to the created conversation.
+     *
+     * @example
+     * ```typescript
+     * // Create a new conversation with metadata
+     * const conversation = await base44.agents.createConversation({
+     *   agent_name: 'support-agent',
+     *   metadata: {
+     *     order_id: 'ORD-789',
+     *     product_id: 'PROD-456',
+     *     category: 'technical-support'
+     *   }
+     * });
+     * console.log(`Created conversation: ${conversation.id}`);
+     * ```
+     */
+    createConversation(conversation: CreateConversationParams): Promise<AgentConversation>;
+    /**
+     * Adds a message to a conversation.
+     *
+     * Sends a message to the agent and updates the conversation. This method
+     * also updates the real-time socket to notify any subscribers.
+     *
+     * @param conversation - The conversation to add the message to.
+     * @param message - The message to add.
+     * @returns Promise resolving to the created message.
+     *
+     * @example
+     * ```typescript
+     * // Send a message to the agent
+     * const message = await base44.agents.addMessage(conversation, {
+     *   role: 'user',
+     *   content: 'Hello, I need help with my order #12345'
+     * });
+     * console.log(`Message sent with ID: ${message.id}`);
+     * ```
+     */
+    addMessage(conversation: AgentConversation, message: Partial<AgentMessage>): Promise<AgentMessage>;
+    /**
+     * Subscribes to real-time updates for a conversation.
+     *
+     * Establishes a WebSocket connection to receive instant updates when new
+     * messages are added to the conversation. Returns an unsubscribe function
+     * to clean up the connection.
+     *
+     * @param conversationId - The conversation ID to subscribe to.
+     * @param onUpdate - Callback function called when the conversation is updated.
+     * @returns Unsubscribe function to stop receiving updates.
+     *
+     * @example
+     * ```typescript
+     * // Subscribe to real-time updates
+     * const unsubscribe = base44.agents.subscribeToConversation(
+     *   'conv-123',
+     *   (updatedConversation) => {
+     *     const latestMessage = updatedConversation.messages[updatedConversation.messages.length - 1];
+     *     console.log('New message:', latestMessage.content);
+     *   }
+     * );
+     *
+     * // Later, clean up the subscription
+     * unsubscribe();
+     * ```
+     */
+    subscribeToConversation(conversationId: string, onUpdate?: (conversation: AgentConversation) => void): () => void;
+    /**
+     * Gets WhatsApp connection URL for an agent.
+     *
+     * Generates a URL that users can use to connect with the agent through WhatsApp.
+     * The URL includes authentication if a token is available.
+     *
+     * @param agentName - The name of the agent.
+     * @returns WhatsApp connection URL.
+     *
+     * @example
+     * ```typescript
+     * // Get WhatsApp connection URL
+     * const whatsappUrl = base44.agents.getWhatsAppConnectURL('support-agent');
+     * console.log(`Connect through WhatsApp: ${whatsappUrl}`);
+     * // User can open this URL to start a WhatsApp conversation
+     * ```
+     */
+    getWhatsAppConnectURL(agentName: string): string;
+}

package/dist/modules/app-logs.d.ts

@@ -1,27 +1,11 @@
 import { AxiosInstance } from "axios";
+import { AppLogsModule } from "./app-logs.types";
 /**
- * Creates the app logs module for the Base44 SDK
- * @param {AxiosInstance} axios - Axios instance
- * @param {string} appId - Application ID
- * @returns {Object} App logs module
+ * Creates the app logs module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns App logs module with methods for tracking and analyzing app usage
+ * @internal
  */
-export declare function createAppLogsModule(axios: AxiosInstance, appId: string): {
-    /**
-     * Log user activity in the app
-     * @param {string} pageName - Name of the page being visited
-     * @returns {Promise<void>}
-     */
-    logUserInApp(pageName: string): Promise<void>;
-    /**
-     * Fetch app logs with optional parameters
-     * @param {Object} params - Query parameters for filtering logs
-     * @returns {Promise<any>} App logs data
-     */
-    fetchLogs(params?: Record<string, any>): Promise<any>;
-    /**
-     * Get app statistics
-     * @param {Object} params - Query parameters for filtering stats
-     * @returns {Promise<any>} App statistics
-     */
-    getStats(params?: Record<string, any>): Promise<any>;
-};
+export declare function createAppLogsModule(axios: AxiosInstance, appId: string): AppLogsModule;

package/dist/modules/app-logs.js

@@ -1,34 +1,24 @@
 /**
- * Creates the app logs module for the Base44 SDK
- * @param {AxiosInstance} axios - Axios instance
- * @param {string} appId - Application ID
- * @returns {Object} App logs module
+ * Creates the app logs module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns App logs module with methods for tracking and analyzing app usage
+ * @internal
  */
 export function createAppLogsModule(axios, appId) {
     const baseURL = `/app-logs/${appId}`;
     return {
-        /**
-         * Log user activity in the app
-         * @param {string} pageName - Name of the page being visited
-         * @returns {Promise<void>}
-         */
+        // Log user activity in the app
         async logUserInApp(pageName) {
             await axios.post(`${baseURL}/log-user-in-app/${pageName}`);
         },
-        /**
-         * Fetch app logs with optional parameters
-         * @param {Object} params - Query parameters for filtering logs
-         * @returns {Promise<any>} App logs data
-         */
+        // Fetch app logs with optional parameters
         async fetchLogs(params = {}) {
             const response = await axios.get(baseURL, { params });
             return response;
         },
-        /**
-         * Get app statistics
-         * @param {Object} params - Query parameters for filtering stats
-         * @returns {Promise<any>} App statistics
-         */
+        // Get app statistics
         async getStats(params = {}) {
             const response = await axios.get(`${baseURL}/stats`, { params });
             return response;