@base44/sdk 0.8.19 → 0.8.21

package/dist/client.js

@@ -3,7 +3,7 @@ import { createEntitiesModule } from "./modules/entities.js";
 import { createIntegrationsModule } from "./modules/integrations.js";
 import { createAuthModule } from "./modules/auth.js";
 import { createSsoModule } from "./modules/sso.js";
-import { createConnectorsModule } from "./modules/connectors.js";
+import { createConnectorsModule, createUserConnectorsModule, } from "./modules/connectors.js";
 import { getAccessToken } from "./utils/auth-utils.js";
 import { createFunctionsModule } from "./modules/functions.js";
 import { createAgentsModule } from "./modules/agents.js";
@@ -114,6 +114,7 @@ export function createClient(config) {
             getSocket,
         }),
         integrations: createIntegrationsModule(axiosClient, appId),
+        connectors: createUserConnectorsModule(axiosClient, appId),
         auth: userAuthModule,
         functions: createFunctionsModule(functionsAxiosClient, appId),
         agents: createAgentsModule({

package/dist/client.types.d.ts

@@ -2,7 +2,7 @@ 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 { ConnectorsModule, UserConnectorsModule } 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";
@@ -21,8 +21,13 @@ export interface CreateClientOptions {
  */
 export interface CreateClientConfig {
     /**
-     * The Base44 server URL. Defaults to "https://base44.app".
-     * @internal
+     * The Base44 server URL.
+     *
+     * You don't need to set this for production use. The SDK defaults to `https://base44.app`.
+     *
+     * Set this when using a local development server to point SDK requests at your local machine instead of the hosted backend.
+     *
+     * @defaultValue `"https://base44.app"`
      */
     serverUrl?: string;
     /**
@@ -82,6 +87,8 @@ export interface Base44Client {
     appLogs: AppLogsModule;
     /** {@link AuthModule | Auth module} for user authentication and management. */
     auth: AuthModule;
+    /** {@link UserConnectorsModule | Connectors module} for app-user OAuth flows. */
+    connectors: UserConnectorsModule;
     /** {@link EntitiesModule | Entities module} for CRUD operations on your data models. */
     entities: EntitiesModule;
     /** {@link FunctionsModule | Functions module} for invoking custom backend functions. */

package/dist/index.d.ts

@@ -4,13 +4,13 @@ import { getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl } from
 export { createClient, createClientFromRequest, Base44Error, getAccessToken, saveAccessToken, removeAccessToken, getLoginUrl, };
 export type { Base44Client, CreateClientConfig, CreateClientOptions, Base44ErrorJSON, };
 export * from "./types.js";
-export type { EntitiesModule, EntityHandler, EntityRecord, EntityTypeRegistry, RealtimeEventType, RealtimeEvent, RealtimeCallback, } from "./modules/entities.types.js";
+export type { DeleteManyResult, DeleteResult, EntitiesModule, EntityHandler, EntityRecord, EntityTypeRegistry, ImportResult, RealtimeEventType, RealtimeEvent, RealtimeCallback, SortField, UpdateManyResult, } 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, FunctionNameRegistry, } from "./modules/functions.types.js";
-export type { AgentsModule, AgentNameRegistry, AgentConversation, AgentMessage, AgentMessageReasoning, AgentMessageToolCall, AgentMessageUsage, AgentMessageCustomContext, AgentMessageMetadata, CreateConversationParams, } from "./modules/agents.types.js";
+export type { IntegrationsModule, IntegrationEndpointFunction, CoreIntegrations, InvokeLLMParams, GenerateImageParams, GenerateImageResult, UploadFileParams, UploadFileResult, SendEmailParams, SendEmailResult, ExtractDataFromUploadedFileParams, ExtractDataFromUploadedFileResult, UploadPrivateFileParams, UploadPrivateFileResult, CreateFileSignedUrlParams, CreateFileSignedUrlResult, } from "./modules/integrations.types.js";
+export type { FunctionsModule, FunctionName, FunctionNameRegistry, } from "./modules/functions.types.js";
+export type { AgentsModule, AgentName, AgentNameRegistry, 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 { ConnectorsModule, UserConnectorsModule, } from "./modules/connectors.types.js";
 export type { CustomIntegrationsModule, CustomIntegrationCallParams, CustomIntegrationCallResponse, } from "./modules/custom-integrations.types.js";
 export type { GetAccessTokenOptions, SaveAccessTokenOptions, RemoveAccessTokenOptions, GetLoginUrlOptions, } from "./utils/auth-utils.types.js";

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

@@ -2,13 +2,19 @@ import { AxiosInstance } from "axios";
 import { RoomsSocket } from "../utils/socket-utils.js";
 import { ModelFilterParams } from "../types.js";
 /**
- * Registry of agent names.
- * Augment this interface to enable autocomplete for agent names.
+ * Registry of agent names. The [`types generate`](/developers/references/cli/commands/types-generate) command fills this registry, then [`AgentName`](#agentname) resolves to a union of the keys.
  */
 export interface AgentNameRegistry {
 }
 /**
- * Agent name type - uses registry keys if augmented, otherwise string.
+ * Union of all agent names from the [`AgentNameRegistry`](#agentnameregistry). Defaults to `string` when no types have been generated.
+ *
+ * @example
+ * ```typescript
+ * // Using generated agent name types
+ * // With generated types, you get autocomplete on agent names
+ * const conversation = await base44.agents.createConversation({ agent_name: 'SupportBot' });
+ * ```
  */
 export type AgentName = keyof AgentNameRegistry extends never ? string : keyof AgentNameRegistry;
 /**
@@ -164,6 +170,8 @@ export interface AgentsModuleConfig {
  * send messages, and subscribe to realtime updates. Conversations can be used
  * for chat interfaces, support systems, or any interactive AI app.
  *
+ * ## Key Features
+ *
  * The agents module enables you to:
  *
  * - **Create conversations** with agents defined in the app.
@@ -173,17 +181,24 @@ export interface AgentsModuleConfig {
  * - **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.
  *
+ * ## Conversation Structure
+ *
  * 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.
  *
+ * ## Authentication Modes
+ *
  * 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. Users must be authenticated to create and access conversations.
  * - **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.
  *
+ * ## Generated Types
+ *
+ * If you're working in a TypeScript project, you can generate types from your agents to get autocomplete on agent names when creating conversations or subscribing to updates. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
  */
 export interface AgentsModule {
     /**
@@ -208,7 +223,7 @@ export interface AgentsModule {
      * 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()}.
+     * all conversations, use {@linkcode getConversations | getConversations()}. To filter, sort, or paginate conversations, use {@linkcode listConversations | listConversations()}.
      *
      * This function returns the complete stored conversation including full tool call results, even for large responses.
      *
@@ -312,8 +327,8 @@ export interface AgentsModule {
      * to clean up the connection.
      *
      * <Note>
-  When receiving messages through this function, tool call data is truncated for efficiency. The `arguments_string` is limited to 500 characters and `results` to 50 characters. The complete tool call data is always saved in storage and can be retrieved by calling {@linkcode getConversation | getConversation()} after the message completes.
-  </Note>
+     * When receiving messages through this function, tool call data is truncated for efficiency. The `arguments_string` is limited to 500 characters and `results` to 50 characters. The complete tool call data is always saved in storage and can be retrieved by calling {@linkcode getConversation | getConversation()} after the message completes.
+     * </Note>
      *
      * @param conversationId - The conversation ID to subscribe to.
      * @param onUpdate - Callback function called when the conversation is updated. The callback receives a conversation object with the following properties:

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

@@ -74,11 +74,15 @@ export type AnalyticsModuleOptions = {
  *
  * <Note> Analytics events tracked with this module appear as custom event cards in the [Analytics dashboard](/documentation/performance-and-seo/app-analytics).</Note>
  *
+ * ## Best Practices
+ *
  * When tracking events:
  *
  * - Choose clear, descriptive event names in snake_case like `signup_button_click` or `purchase_completed` rather than generic names like `click`.
  * - Include relevant context in your properties such as identifiers like `product_id`, measurements like `price`, and flags like `is_first_purchase`.
  *
+ * ## Authentication Modes
+ *
  * This module is only available in user authentication mode (`base44.analytics`).
  */
 export interface AnalyticsModule {

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

@@ -3,6 +3,8 @@
  *
  * This module provides a method to log user activity. The logs are reflected in the Analytics page in the app dashboard.
  *
+ * ## Authentication Modes
+ *
  * This module is available to use with a client in all authentication modes.
  */
 export interface AppLogsModule {

package/dist/modules/auth.js

@@ -37,9 +37,18 @@ export function createAuthModule(axios, functionsAxiosClient, appId, options) {
         loginWithProvider(provider, fromUrl = "/") {
             // Build the full redirect URL
             const redirectUrl = new URL(fromUrl, window.location.origin).toString();
-            // Build the provider login URL (google is the default, so no provider path needed)
-            const providerPath = provider === "google" ? "" : `/${provider}`;
-            const loginUrl = `${options.appBaseUrl}/api/apps/auth${providerPath}/login?app_id=${appId}&from_url=${encodeURIComponent(redirectUrl)}`;
+            const queryParams = `app_id=${appId}&from_url=${encodeURIComponent(redirectUrl)}`;
+            // SSO uses a different URL structure with appId in the path
+            let authPath;
+            if (provider === "sso") {
+                authPath = `/apps/${appId}/auth/sso/login`;
+            }
+            else {
+                // Google is the default provider, so no provider path segment needed
+                const providerPath = provider === "google" ? "" : `/${provider}`;
+                authPath = `/apps/auth${providerPath}/login`;
+            }
+            const loginUrl = `${options.appBaseUrl}/api${authPath}?${queryParams}`;
             // Redirect to the provider login page
             window.location.href = loginUrl;
         },

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

@@ -96,6 +96,8 @@ export interface AuthModuleOptions {
 /**
  * Authentication module for managing user authentication and authorization. The module automatically stores tokens in local storage when available and manages authorization headers for API requests.
  *
+ * ## Features
+ *
  * This module provides comprehensive authentication functionality including:
  * - Email/password login and registration
  * - Token management
@@ -104,6 +106,8 @@ export interface AuthModuleOptions {
  * - OTP verification
  * - User invitations
  *
+ * ## Authentication Modes
+ *
  * The auth module is only available in user authentication mode (`base44.auth`).
  */
 export interface AuthModule {
@@ -177,24 +181,39 @@ export interface AuthModule {
      * Initiates an OAuth login flow with one of the built-in providers. Requires a browser environment and can't be used in the backend.
      *
      * Supported providers:
-     * - `'google'` - {@link https://developers.google.com/identity/protocols/oauth2 | Google OAuth}. Enabled by default.
-     * - `'microsoft'` - {@link https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow | Microsoft OAuth}. Enable Microsoft in your app's authentication settings before specifying this provider.
-     * - `'facebook'` - {@link https://developers.facebook.com/docs/facebook-login | Facebook Login}. Enable this in your app's authentication settings before using.
+     * - `'google'`: {@link https://developers.google.com/identity/protocols/oauth2 | Google OAuth}. Enabled by default.
+     * - `'microsoft'`: {@link https://learn.microsoft.com/en-us/entra/identity-platform/v2-oauth2-auth-code-flow | Microsoft OAuth}. Enable Microsoft in your app's authentication settings before specifying this provider.
+     * - `'facebook'`: {@link https://developers.facebook.com/docs/facebook-login | Facebook Login}. Enable Facebook in your app's authentication settings before using.
+     * - `'apple'`: {@link https://developer.apple.com/sign-in-with-apple/ | Sign in with Apple}. Enable Apple in your app's authentication settings before using this provider.
+     * - `'sso'`: Enterprise SSO. {@link https://docs.base44.com/Setting-up-your-app/Setting-up-SSO | Set up an SSO provider} in your app's authentication settings before using this provider.
      *
-     * @param provider - The authentication provider to use: `'google'`, `'microsoft'`, or `'facebook'`.
+     * @param provider - The authentication provider to use: `'google'`, `'microsoft'`, `'facebook'`, `'apple'`, or `'sso'`.
      * @param fromUrl - URL to redirect to after successful authentication. Defaults to `'/'`.
      *
      * @example
      * ```typescript
-     * // Login with Google and return to current page
+     * // Google
      * base44.auth.loginWithProvider('google', window.location.pathname);
      * ```
      *
      * @example
      * ```typescript
-     * // Login with Microsoft and redirect to dashboard
+     * // Microsoft
      * base44.auth.loginWithProvider('microsoft', '/dashboard');
      * ```
+     *
+     * @example
+     * ```typescript
+     * // Apple
+     * base44.auth.loginWithProvider('apple', '/dashboard');
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // SSO
+     * base44.auth.loginWithProvider('sso', '/dashboard');
+     * ```
+     *
      */
     loginWithProvider(provider: string, fromUrl?: string): void;
     /**

package/dist/modules/connectors.d.ts

@@ -1,5 +1,5 @@
 import { AxiosInstance } from "axios";
-import { ConnectorsModule } from "./connectors.types.js";
+import { ConnectorsModule, UserConnectorsModule } from "./connectors.types.js";
 /**
  * Creates the Connectors module for the Base44 SDK.
  *
@@ -9,3 +9,12 @@ import { ConnectorsModule } from "./connectors.types.js";
  * @internal
  */
 export declare function createConnectorsModule(axios: AxiosInstance, appId: string): ConnectorsModule;
+/**
+ * Creates the user-scoped Connectors module (app-user OAuth flows).
+ *
+ * @param axios - Axios instance (user-scoped client)
+ * @param appId - Application ID
+ * @returns User connectors module with app-user OAuth methods
+ * @internal
+ */
+export declare function createUserConnectorsModule(axios: AxiosInstance, appId: string): UserConnectorsModule;

package/dist/modules/connectors.js

@@ -8,8 +8,11 @@
  */
 export function createConnectorsModule(axios, appId) {
     return {
-        // Retrieve an OAuth access token for a specific external integration type
-        // @ts-expect-error Return type mismatch with interface - implementation returns object, interface expects string
+        /**
+         * Retrieve an OAuth access token for a specific external integration type.
+         * @deprecated Use getConnection(integrationType) and use the returned accessToken (and connectionConfig when needed) instead.
+         */
+        // @ts-expect-error Return type mismatch with interface - implementation returns string, interface expects string but implementation is typed as ConnectorAccessTokenResponse
         async getAccessToken(integrationType) {
             if (!integrationType || typeof integrationType !== "string") {
                 throw new Error("Integration type is required and must be a string");
@@ -18,5 +21,51 @@ export function createConnectorsModule(axios, appId) {
             // @ts-expect-error
             return response.access_token;
         },
+        async getConnection(integrationType) {
+            var _a;
+            if (!integrationType || typeof integrationType !== "string") {
+                throw new Error("Integration type is required and must be a string");
+            }
+            const response = await axios.get(`/apps/${appId}/external-auth/tokens/${integrationType}`);
+            const data = response;
+            return {
+                accessToken: data.access_token,
+                connectionConfig: (_a = data.connection_config) !== null && _a !== void 0 ? _a : null,
+            };
+        },
+    };
+}
+/**
+ * Creates the user-scoped Connectors module (app-user OAuth flows).
+ *
+ * @param axios - Axios instance (user-scoped client)
+ * @param appId - Application ID
+ * @returns User connectors module with app-user OAuth methods
+ * @internal
+ */
+export function createUserConnectorsModule(axios, appId) {
+    return {
+        async getCurrentAppUserAccessToken(connectorId) {
+            if (!connectorId || typeof connectorId !== "string") {
+                throw new Error("Connector ID is required and must be a string");
+            }
+            const response = await axios.get(`/apps/${appId}/app-user-auth/connectors/${connectorId}/token`);
+            const data = response;
+            return data.access_token;
+        },
+        async connectAppUser(connectorId) {
+            if (!connectorId || typeof connectorId !== "string") {
+                throw new Error("Connector ID is required and must be a string");
+            }
+            const response = await axios.post(`/apps/${appId}/app-user-auth/connectors/${connectorId}/initiate`);
+            const data = response;
+            return data.redirect_url;
+        },
+        async disconnectAppUser(connectorId) {
+            if (!connectorId || typeof connectorId !== "string") {
+                throw new Error("Connector ID is required and must be a string");
+            }
+            await axios.delete(`/apps/${appId}/app-user-auth/connectors/${connectorId}`);
+        },
     };
 }

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

@@ -1,12 +1,18 @@
 /**
- * Registry of connector integration types.
- * Augment this interface to enable autocomplete for connector integration types.
+ * Registry of connector integration type names. The [`types generate`](/developers/references/cli/commands/types-generate) command fills this registry, then [`ConnectorIntegrationType`](#connectorintegrationtype) resolves to a union of the keys.
  */
 export interface ConnectorIntegrationTypeRegistry {
 }
 /**
- * The type of external integration/connector, such as `'googlecalendar'`, `'slack'`, or `'github'`.
- * Uses registry keys if augmented, otherwise falls back to string.
+ * Union of all connector integration type names from the [`ConnectorIntegrationTypeRegistry`](#connectorintegrationtyperegistry). Defaults to `string` when no types have been generated.
+ *
+ * @example
+ * ```typescript
+ * // Using generated connector type names
+ * // With generated types, you get autocomplete on integration types
+ * const connection = await base44.asServiceRole.connectors.getConnection('googlecalendar');
+ * const token = connection.accessToken;
+ * ```
  */
 export type ConnectorIntegrationType = keyof ConnectorIntegrationTypeRegistry extends never ? string : keyof ConnectorIntegrationTypeRegistry;
 /**
@@ -14,28 +20,91 @@ export type ConnectorIntegrationType = keyof ConnectorIntegrationTypeRegistry ex
  */
 export interface ConnectorAccessTokenResponse {
     access_token: string;
+    integration_type: string;
+    connection_config: Record<string, string> | null;
+}
+/**
+ * Connection details.
+ */
+export interface ConnectorConnectionResponse {
+    /** The OAuth access token for the external service. */
+    accessToken: string;
+    /** Key-value configuration for the connection, or `null` if the connector does not provide one. */
+    connectionConfig: Record<string, string> | null;
 }
 /**
- * Connectors module for managing OAuth tokens for external services.
+ * Connectors module for managing app-scoped OAuth tokens for external services.
  *
- * This module allows you to retrieve OAuth access tokens for external services that the app has connected to. Connectors are app-scoped. When an app builder connects an integration like Google Calendar or Slack, all users of the app share that same connection.
+ * This module allows you to retrieve OAuth access tokens for external services that the app has connected to. Connectors are app-scoped. When an app builder connects an integration like Google Calendar, Slack, or GitHub, all users of the app share that same connection.
  *
  * Unlike the integrations module that provides pre-built functions, connectors give you
  * raw OAuth tokens so you can call external service APIs directly with full control over
  * the API calls you make. This is useful when you need custom API interactions that aren't
  * covered by Base44's pre-built integrations.
  *
+ * ## Available connectors
+ *
+ * All connectors work through [`getConnection()`](#getconnection). Pass the integration type string and use the returned OAuth token to call the external service's API directly.
+ *
+ * | Service | Type identifier |
+ * |---|---|
+ * | Airtable | `airtable` |
+ * | Box | `box` |
+ * | ClickUp | `clickup` |
+ * | Discord | `discord` |
+ * | Dropbox | `dropbox` |
+ * | GitHub | `github` |
+ * | Gmail | `gmail` |
+ * | Google Analytics | `google_analytics` |
+ * | Google BigQuery | `googlebigquery` |
+ * | Google Calendar | `googlecalendar` |
+ * | Google Classroom | `google_classroom` |
+ * | Google Docs | `googledocs` |
+ * | Google Drive | `googledrive` |
+ * | Google Search Console | `google_search_console` |
+ * | Google Sheets | `googlesheets` |
+ * | Google Slides | `googleslides` |
+ * | HubSpot | `hubspot` |
+ * | Linear | `linear` |
+ * | LinkedIn | `linkedin` |
+ * | Microsoft Teams | `microsoft_teams` |
+ * | Microsoft OneDrive | `one_drive` |
+ * | Notion | `notion` |
+ * | Outlook | `outlook` |
+ * | Salesforce | `salesforce` |
+ * | SharePoint | `share_point` |
+ * | Slack User | `slack` |
+ * | Slack Bot | `slackbot` |
+ * | Splitwise | `splitwise` |
+ * | TikTok | `tiktok` |
+ * | Typeform | `typeform` |
+ * | Wix | `wix` |
+ * | Wrike | `wrike` |
+ *
+ * See the integration guides for more details:
+ *
+ * - **Scopes and permissions**: {@link https://docs.base44.com/Integrations/gmail-connector#gmail-scopes-and-permissions | Gmail}, {@link https://docs.base44.com/Integrations/linkedin-connector#linkedin-scopes-and-permissions | LinkedIn}, {@link https://docs.base44.com/Integrations/slack-connector#slack-scopes-and-permissions | Slack}, {@link https://docs.base44.com/Integrations/github-connector#github-scopes-and-permissions | GitHub}
+ * - **Slack connector types**: {@link https://docs.base44.com/Integrations/slack-connector#about-the-slack-connectors | About the Slack connectors} explains the difference between `slack` and `slackbot`
+ *
+ * ## Authentication Modes
+ *
  * This module is only available to use with a client in service role authentication mode, which means it can only be used in backend environments.
+ *
+ * ## Dynamic Types
+ *
+ * If you're working in a TypeScript project, you can generate types from your app's connector configurations to get autocomplete on integration type names when calling `getConnection()`. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
  */
 export interface ConnectorsModule {
     /**
-     * Retrieves an OAuth access token for a specific external integration type.
+     * Retrieves an OAuth access token for a specific [external integration type](#available-connectors).
+     *
+     * @deprecated Use {@link getConnection} instead.
      *
      * Returns the OAuth token string for an external service that an app builder
      * has connected to. This token represents the connected app builder's account
      * and can be used to make authenticated API calls to that external service on behalf of the app.
      *
-     * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, or `'github'`.
+     * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, `'slackbot'`, `'github'`, or `'discord'`. See [Available connectors](#available-connectors) for the full list.
      * @returns Promise resolving to the access token string.
      *
      * @example
@@ -57,8 +126,8 @@ export interface ConnectorsModule {
      *
      * @example
      * ```typescript
-     * // Slack connection
-     * // Get Slack OAuth token and list channels
+     * // Slack User connection
+     * // Get Slack user token and list channels
      * const slackToken = await base44.asServiceRole.connectors.getAccessToken('slack');
      *
      * // List all public and private channels
@@ -70,6 +139,158 @@ export interface ConnectorsModule {
      *
      * const data = await slackResponse.json();
      * ```
+     *
+     * @example
+     * ```typescript
+     * // Slack Bot connection
+     * // Get Slack bot token and post a message with a custom bot identity
+     * const botToken = await base44.asServiceRole.connectors.getAccessToken('slackbot');
+     *
+     * const response = await fetch('https://slack.com/api/chat.postMessage', {
+     *   method: 'POST',
+     *   headers: {
+     *     'Authorization': `Bearer ${botToken}`,
+     *     'Content-Type': 'application/json'
+     *   },
+     *   body: JSON.stringify({
+     *     channel: '#alerts',
+     *     text: 'Deployment to production completed successfully.',
+     *     username: 'Deploy Bot',
+     *     icon_emoji: ':rocket:'
+     *   })
+     * });
+     *
+     * const result = await response.json();
+     * ```
      */
     getAccessToken(integrationType: ConnectorIntegrationType): Promise<string>;
+    /**
+     * Retrieves the OAuth access token and connection configuration for a specific [external integration type](#available-connectors).
+     *
+     * Some connectors require connection-specific parameters to build API calls.
+     * In such cases, the returned `connectionConfig` is an object with the additional parameters. If there are no extra parameters needed for the connection, the `connectionConfig` is `null`.
+     *
+     * For example, a service might need a subdomain to construct the API URL in
+     * the form of `{subdomain}.example.com`. In such a case the subdomain will be available as a property of the `connectionConfig` object.
+     *
+     * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, `'slackbot'`, `'github'`, or `'discord'`. See [Available connectors](#available-connectors) for the full list.
+     * @returns Promise resolving to a {@link ConnectorConnectionResponse} with `accessToken` and `connectionConfig`.
+     *
+     * @example
+     * ```typescript
+     * // Google Calendar connection
+     * // Get Google Calendar OAuth token and fetch upcoming events
+     * const { accessToken } = await base44.asServiceRole.connectors.getConnection('googlecalendar');
+     *
+     * const timeMin = new Date().toISOString();
+     * const url = `https://www.googleapis.com/calendar/v3/calendars/primary/events?maxResults=10&orderBy=startTime&singleEvents=true&timeMin=${timeMin}`;
+     *
+     * const calendarResponse = await fetch(url, {
+     *   headers: { Authorization: `Bearer ${accessToken}` }
+     * });
+     *
+     * const events = await calendarResponse.json();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Slack connection
+     * // Get Slack OAuth token and list channels
+     * const { accessToken } = await base44.asServiceRole.connectors.getConnection('slack');
+     *
+     * const url = 'https://slack.com/api/conversations.list?types=public_channel,private_channel&limit=100';
+     *
+     * const slackResponse = await fetch(url, {
+     *   headers: { Authorization: `Bearer ${accessToken}` }
+     * });
+     *
+     * const data = await slackResponse.json();
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Using connectionConfig
+     * // Some connectors return a subdomain or other params needed to build the API URL
+     * const { accessToken, connectionConfig } = await base44.asServiceRole.connectors.getConnection('myservice');
+     *
+     * const subdomain = connectionConfig?.subdomain;
+     * const response = await fetch(
+     *   `https://${subdomain}.example.com/api/v1/resources`,
+     *   { headers: { Authorization: `Bearer ${accessToken}` } }
+     * );
+     *
+     * const data = await response.json();
+     * ```
+     */
+    getConnection(integrationType: ConnectorIntegrationType): Promise<ConnectorConnectionResponse>;
+}
+/**
+ * User-scoped connectors module for managing app-user OAuth connections.
+ *
+ * This module provides methods for app-user OAuth flows: initiating an OAuth connection,
+ * retrieving the end user's access token, and disconnecting the end user's connection.
+ *
+ * Unlike {@link ConnectorsModule | ConnectorsModule} which manages app-scoped tokens,
+ * this module manages tokens scoped to individual end users. Methods are keyed on
+ * the connector ID (the OrgConnector's database ID) rather than the integration type.
+ *
+ * Available via `base44.connectors`.
+ */
+export interface UserConnectorsModule {
+    /**
+     * Retrieves an OAuth access token for an end user's connection to a specific connector.
+     *
+     * Returns the OAuth token string that belongs to the currently authenticated end user
+     * for the specified connector.
+     *
+     * @param connectorId - The connector ID (OrgConnector database ID).
+     * @returns Promise resolving to the access token string.
+     *
+     * @example
+     * ```typescript
+     * // Get the end user's access token for a connector
+     * const token = await base44.connectors.getCurrentAppUserAccessToken('abc123def');
+     *
+     * const response = await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events', {
+     *   headers: { 'Authorization': `Bearer ${token}` }
+     * });
+     * ```
+     */
+    getCurrentAppUserAccessToken(connectorId: string): Promise<string>;
+    /**
+     * Initiates the app-user OAuth flow for a specific connector.
+     *
+     * Returns a redirect URL that the end user should be navigated to in order to
+     * authenticate with the external service. The scopes and integration type are
+     * derived from the connector configuration server-side.
+     *
+     * @param connectorId - The connector ID (OrgConnector database ID).
+     * @returns Promise resolving to the redirect URL string.
+     *
+     * @example
+     * ```typescript
+     * // Start OAuth for the end user
+     * const redirectUrl = await base44.connectors.connectAppUser('abc123def');
+     *
+     * // Redirect the user to the OAuth provider
+     * window.location.href = redirectUrl;
+     * ```
+     */
+    connectAppUser(connectorId: string): Promise<string>;
+    /**
+     * Disconnects an end user's OAuth connection for a specific connector.
+     *
+     * Removes the stored OAuth credentials for the currently authenticated end user's
+     * connection to the specified connector.
+     *
+     * @param connectorId - The connector ID (OrgConnector database ID).
+     * @returns Promise resolving when the connection has been removed.
+     *
+     * @example
+     * ```typescript
+     * // Disconnect the end user's connection
+     * await base44.connectors.disconnectAppUser('abc123def');
+     * ```
+     */
+    disconnectAppUser(connectorId: string): Promise<void>;
 }

package/dist/modules/entities.js

@@ -106,6 +106,14 @@ function createEntityHandler(axios, appId, entityName, getSocket) {
         async bulkCreate(data) {
             return axios.post(`${baseURL}/bulk`, data);
         },
+        // Update multiple entities matching a query using a MongoDB update operator
+        async updateMany(query, data) {
+            return axios.patch(`${baseURL}/update-many`, { query, data });
+        },
+        // Update multiple entities by ID, each with its own update data
+        async bulkUpdate(data) {
+            return axios.put(`${baseURL}/bulk`, data);
+        },
         // Import entities from a file
         async importEntities(file) {
             const formData = new FormData();

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

@@ -27,41 +27,55 @@ export type RealtimeCallback<T = any> = (event: RealtimeEvent<T>) => void;
  * Result returned when deleting a single entity.
  */
 export interface DeleteResult {
-    /** Whether the deletion was successful */
+    /** Whether the deletion was successful. */
     success: boolean;
 }
 /**
  * Result returned when deleting multiple entities.
  */
 export interface DeleteManyResult {
-    /** Whether the deletion was successful */
+    /** Whether the deletion was successful. */
     success: boolean;
-    /** Number of entities that were deleted */
+    /** Number of entities that were deleted. */
     deleted: number;
 }
+/**
+ * Result returned when updating multiple entities via a query.
+ */
+export interface UpdateManyResult {
+    /** Whether the operation was successful. */
+    success: boolean;
+    /** Number of entities that were updated. */
+    updated: number;
+    /** Whether there are more entities matching the query that were not updated in this batch. When `true`, call `updateMany` again with the same query to update the next batch. */
+    has_more: boolean;
+}
 /**
  * Result returned when importing entities from a file.
  *
  * @typeParam T - The entity type for imported records. Defaults to `any`.
  */
 export interface ImportResult<T = any> {
-    /** Status of the import operation */
+    /** Status of the import operation. */
     status: "success" | "error";
-    /** Details message, e.g., "Successfully imported 3 entities with RLS enforcement" */
+    /** Details message, e.g., "Successfully imported 3 entities with RLS enforcement". */
     details: string | null;
-    /** Array of created entity objects when successful, or null on error */
+    /** Array of created entity objects when successful, or null on error. */
     output: T[] | null;
 }
 /**
  * Sort field type for entity queries.
  *
- * Supports ascending (no prefix or `'+'`) and descending (`'-'`) sorting.
+ * Accepts any field name from the entity type with an optional prefix:
+ * - `'+'` prefix or no prefix: ascending sort
+ * - `'-'` prefix: descending sort
  *
  * @typeParam T - The entity type to derive sortable fields from.
  *
  * @example
  * ```typescript
- * // Ascending sort (default)
+ * // Specify sort direction by prefixing field names with + or -
+ * // Ascending sort
  * 'created_date'
  * '+created_date'
  *
@@ -71,7 +85,7 @@ export interface ImportResult<T = any> {
  */
 export type SortField<T> = (keyof T & string) | `+${keyof T & string}` | `-${keyof T & string}`;
 /**
- * Fields added by the server to every entity record (id, dates, created_by, etc.).
+ * Fields added by the server to every entity record, such as `id`, `created_date`, `updated_date`, and `created_by`.
  */
 interface ServerEntityFields {
     /** Unique identifier of the record */
@@ -88,13 +102,29 @@ interface ServerEntityFields {
     is_sample?: boolean;
 }
 /**
- * Registry mapping entity names to their TypeScript types.
- * Augment this interface with your entity schema (user-defined fields only).
+ * Registry mapping entity names to their TypeScript types. The [`types generate`](/developers/references/cli/commands/types-generate) command fills this registry, then [`EntityRecord`](#entityrecord) adds server fields.
  */
 export interface EntityTypeRegistry {
 }
 /**
- * Full record type for each entity: schema fields + server-injected fields (id, created_date, etc.).
+ * Combines the [`EntityTypeRegistry`](#entitytyperegistry) schemas with server fields like `id`, `created_date`, and `updated_date` to give the complete record type for each entity. Use this when you need to type variables holding entity data.
+ *
+ * @example
+ * ```typescript
+ * // Using EntityRecord to get the complete type for an entity
+ * // Combine your schema with server fields (id, created_date, etc.)
+ * type TaskRecord = EntityRecord['Task'];
+ *
+ * const task: TaskRecord = await base44.entities.Task.create({
+ *   title: 'My task',
+ *   status: 'pending'
+ * });
+ *
+ * // Task now includes both your fields and server fields:
+ * console.log(task.id);           // Server field
+ * console.log(task.created_date); // Server field
+ * console.log(task.title);        // Your field
+ * ```
  */
 export type EntityRecord = {
     [K in keyof EntityTypeRegistry]: EntityTypeRegistry[K] & ServerEntityFields;
@@ -329,6 +359,87 @@ export interface EntityHandler<T = any> {
      * ```
      */
     bulkCreate(data: Partial<T>[]): Promise<T[]>;
+    /**
+     * Updates multiple records matching a query using a MongoDB update operator.
+     *
+     * Applies the same update operation to all records matching the query.
+     * The `data` parameter must contain one or more MongoDB update operators
+     * (e.g., `$set`, `$inc`, `$push`). Multiple operators can be combined in a
+     * single call, but each field may only appear in one operator.
+     *
+     * Results are batched in groups of up to 500 — when `has_more` is `true`
+     * in the response, call `updateMany` again with the same query to update
+     * the next batch.
+     *
+     * @param query - Query object to filter which records to update. Records matching all
+     * specified criteria will be updated.
+     * @param data - Update operation object containing one or more MongoDB update operators.
+     * Each field may only appear in one operator per call.
+     * Supported operators: `$set`, `$rename`, `$unset`, `$inc`, `$mul`, `$min`, `$max`,
+     * `$currentDate`, `$addToSet`, `$push`, `$pull`.
+     * @returns Promise resolving to the update result.
+     *
+     * @example
+     * ```typescript
+     * // Set status to 'archived' for all completed records
+     * const result = await base44.entities.MyEntity.updateMany(
+     *   { status: 'completed' },
+     *   { $set: { status: 'archived' } }
+     * );
+     * console.log(`Updated ${result.updated} records`);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Combine multiple operators in a single call
+     * const result = await base44.entities.MyEntity.updateMany(
+     *   { category: 'sales' },
+     *   { $set: { status: 'done' }, $inc: { view_count: 1 } }
+     * );
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Handle batched updates for large datasets
+     * let hasMore = true;
+     * let totalUpdated = 0;
+     * while (hasMore) {
+     *   const result = await base44.entities.MyEntity.updateMany(
+     *     { status: 'pending' },
+     *     { $set: { status: 'processed' } }
+     *   );
+     *   totalUpdated += result.updated;
+     *   hasMore = result.has_more;
+     * }
+     * ```
+     */
+    updateMany(query: Partial<T>, data: Record<string, Record<string, any>>): Promise<UpdateManyResult>;
+    /**
+     * Updates multiple records in a single request, each with its own update data.
+     *
+     * Unlike `updateMany` which applies the same update to all matching records,
+     * `bulkUpdate` allows different updates for each record. Each item in the
+     * array must include an `id` field identifying which record to update.
+     *
+     * **Note:** Maximum 500 items per request.
+     *
+     * @param data - Array of update objects (max 500). Each object must have an `id` field
+     * and any number of fields to update.
+     * @returns Promise resolving to an array of updated records.
+     *
+     * @example
+     * ```typescript
+     * // Update multiple records with different data
+     * const updated = await base44.entities.MyEntity.bulkUpdate([
+     *   { id: 'entity-1', status: 'paid', amount: 999 },
+     *   { id: 'entity-2', status: 'cancelled' },
+     *   { id: 'entity-3', name: 'Renamed Item' }
+     * ]);
+     * ```
+     */
+    bulkUpdate(data: (Partial<T> & {
+        id: string;
+    })[]): Promise<T[]>;
     /**
      * Imports records from a file.
      *
@@ -401,17 +512,29 @@ type DynamicEntitiesModule = {
  * Entities are accessed dynamically using the pattern:
  * `base44.entities.EntityName.method()`
  *
- * This module is available to use with a client in all three authentication modes:
+ * This module is available to use with a client in all authentication modes:
  *
  * - **Anonymous or User authentication** (`base44.entities`): Access is scoped to the current user's permissions. Anonymous users can only access public entities, while authenticated users can access entities they have permission to view or modify.
  * - **Service role authentication** (`base44.asServiceRole.entities`): Operations have elevated admin-level permissions. Can access all entities that the app's admin role has access to.
  *
+ * ## Entity Handlers
+ *
+ * An entity handler is the object you get when you access an entity through `base44.entities.EntityName`. Every entity in your app automatically gets a handler with CRUD methods for managing records.
+ *
+ * For example, `base44.entities.Task` is an entity handler for Task records, and `base44.entities.User` is an entity handler for User records. Each handler provides methods like `list()`, `create()`, `update()`, and `delete()`.
+ *
+ * You don't need to instantiate or import entity handlers. They're automatically available for every entity you create in your app.
+ *
  * ## Built-in User Entity
  *
  * Every app includes a built-in `User` entity that stores user account information. This entity has special security rules that can't be changed.
  *
  * Regular users can only read and update their own user record. With service role authentication, you can read, update, and delete any user. You can't create users using the entities module. Instead, use the functions of the {@link AuthModule | auth module} to invite or register new users.
  *
+ * ## Generated Types
+ *
+ * If you're working in a TypeScript project, you can generate types from your entity schemas to get autocomplete and type checking on all entity methods. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
+ *
  * @example
  * ```typescript
  * // Get all records from the MyEntity entity

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

@@ -1,11 +1,17 @@
 /**
- * Registry of function names.
- * Augment this interface to enable autocomplete for function names.
+ * Registry of function names. The [`types generate`](/developers/references/cli/commands/types-generate) command fills this registry, then [`FunctionName`](#functionname) resolves to a union of the keys.
  */
 export interface FunctionNameRegistry {
 }
 /**
- * Function name type - uses registry keys if augmented, otherwise string.
+ * Union of all function names from the [`FunctionNameRegistry`](#functionnameregistry). Defaults to `string` when no types have been generated.
+ *
+ * @example
+ * ```typescript
+ * // Using generated function name types
+ * // With generated types, you get autocomplete on function names
+ * await base44.functions.invoke('calculateTotal', { items: ['item1', 'item2'] });
+ * ```
  */
 export type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;
 /**
@@ -13,10 +19,16 @@ export type FunctionName = keyof FunctionNameRegistry extends never ? string : k
  *
  * This module allows you to invoke the custom backend functions defined in the app.
  *
+ * ## Authentication Modes
+ *
  * This module is available to use with a client in all authentication modes:
  *
  * - **Anonymous or User authentication** (`base44.functions`): Functions are invoked with the current user's permissions. Anonymous users invoke functions without authentication, while authenticated users invoke functions with their authentication context.
  * - **Service role authentication** (`base44.asServiceRole.functions`): Functions are invoked with elevated admin-level permissions. The function code receives a request with admin authentication context.
+ *
+ * ## Generated Types
+ *
+ * If you're working in a TypeScript project, you can generate types from your backend functions to get autocomplete on function names when calling `invoke()`. See the [Dynamic Types](/developers/references/sdk/getting-started/dynamic-types) guide to get started.
  */
 export interface FunctionsModule {
     /**
@@ -36,7 +48,6 @@ export interface FunctionsModule {
      * // Basic function call
      * const result = await base44.functions.invoke('calculateTotal', {
      *   items: ['item1', 'item2'],
-     *   discount: 0.1
      * });
      * console.log(result.data.total);
      * ```

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

@@ -12,18 +12,25 @@ export type IntegrationEndpointFunction = (data: Record<string, any>) => Promise
 /**
  * A package containing integration endpoints.
  *
- * Provides dynamic access to integration endpoints within a package.
- * Each endpoint is accessed as a property that returns a function to invoke it.
+ * An integration package is a collection of endpoint functions indexed by endpoint name.
+ * Both `Core` and `custom` are integration packages that implement this structure.
  *
- * @example
+ * @example **Core package**
  * ```typescript
- * // Access endpoints dynamically
- * const result = await integrations.Core.SendEmail({
- *   to: 'user@example.com',
- *   subject: 'Hello',
- *   body: 'Message'
+ * await base44.integrations.Core.InvokeLLM({
+ *   prompt: 'Explain quantum computing',
+ *   model: 'gpt_5'
  * });
  * ```
+ *
+ * @example **custom package**
+ * ```typescript
+ * await base44.integrations.custom.call(
+ *   'github',
+ *   'get:/repos/{owner}/{repo}',
+ *   { pathParams: { owner: 'myorg', repo: 'myrepo' } }
+ * );
+ * ```
  */
 export type IntegrationPackage = {
     [endpointName: string]: IntegrationEndpointFunction;
@@ -34,6 +41,11 @@ export type IntegrationPackage = {
 export interface InvokeLLMParams {
     /** The prompt text to send to the model */
     prompt: string;
+    /** Optionally specify a model to override the app-level model setting for this specific call.
+     *
+     * Options: `"gpt_5_mini"`, `"gemini_3_flash"`, `"gpt_5"`, `"gemini_3_pro"`, `"claude_sonnet_4_6"`, `"claude_opus_4_6"`
+     */
+    model?: 'gpt_5_mini' | 'gemini_3_flash' | 'gpt_5' | 'gemini_3_pro' | 'claude_sonnet_4_6' | 'claude_opus_4_6';
     /** If set to `true`, the LLM will use Google Search, Maps, and News to gather real-time context before answering.
      * @default false
      */
@@ -324,6 +336,8 @@ export interface CoreIntegrations {
  *
  * This module provides access to integration methods for interacting with external services. Unlike the connectors module that gives you raw OAuth tokens, integrations provide pre-built functions that Base44 executes on your behalf.
  *
+ * ## Integration Types
+ *
  * There are two types of integrations:
  *
  * - **Built-in integrations** (`Core`): Pre-built functions provided by Base44 for common tasks such as AI-powered text generation, image creation, file uploads, and email. Access core integration methods using:
@@ -331,12 +345,14 @@ export interface CoreIntegrations {
  *   base44.integrations.Core.FunctionName(params)
  *   ```
  *
- * - **Custom integrations** (`custom`): Pre-configured external APIs. Custom integration calls are proxied through Base44's backend, so credentials are never exposed to the frontend. Access custom integration methods using:
+ * - **Custom workspace integrations** (`custom`): Pre-configured external APIs set up by workspace administrators. Workspace integration calls are proxied through Base44's backend, so credentials are never exposed to the frontend. Access custom workspace integration methods using:
  *   ```
  *   base44.integrations.custom.call(slug, operationId, params)
  *   ```
  *
- *   <Info>To call a custom integration, it must be pre-configured by a workspace administrator who imports an OpenAPI specification.</Info>
+ *   <Info>To call a custom workspace integration, it must be pre-configured by a workspace administrator who imports an OpenAPI specification. Learn more about [custom workspace integrations](/documentation/integrations/managing-workspace-integrations).</Info>
+ *
+ * ## Authentication Modes
  *
  * This module is available to use with a client in all authentication modes:
  *
@@ -346,18 +362,52 @@ export interface CoreIntegrations {
 export type IntegrationsModule = {
     /**
      * Core package containing built-in Base44 integration functions.
+     *
+     * @example
+     * ```typescript
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: 'Explain quantum computing',
+     *   model: 'gpt_5'
+     * });
+     * ```
      */
     Core: CoreIntegrations;
     /**
-     * Custom integrations module for calling pre-configured external APIs.
+     * Workspace integrations module for calling pre-configured external APIs.
+     *
+     * @example
+     * ```typescript
+     * const result = await base44.integrations.custom.call(
+     *   'github',
+     *   'get:/repos/{owner}/{repo}',
+     *   { pathParams: { owner: 'myorg', repo: 'myrepo' } }
+     * );
+     * ```
      */
     custom: CustomIntegrationsModule;
 } & {
     /**
      * Access to additional integration packages.
      *
-     * Additional integration packages may be added in the future and will be
-     * accessible using the same pattern as Core.
+     * Allows accessing integration packages as properties. This enables both `Core` and `custom` packages,
+     * as well as any future integration packages that may be added.
+     *
+     * @example **Use Core integrations**
+     * ```typescript
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: 'Explain quantum computing',
+     *   model: 'gpt_5'
+     * });
+     * ```
+     *
+     * @example **Use custom integrations**
+     * ```typescript
+     * const result = await base44.integrations.custom.call(
+     *   'github',
+     *   'get:/repos/{owner}/{repo}',
+     *   { pathParams: { owner: 'myorg', repo: 'myrepo' } }
+     * );
+     * ```
      */
     [packageName: string]: IntegrationPackage;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@base44/sdk",
-  "version": "0.8.19",
+  "version": "0.8.21",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",