@base44/sdk 0.8.19 → 0.8.20

package/dist/index.d.ts

@@ -4,11 +4,11 @@ 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, } 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";

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 {
@@ -179,22 +183,36 @@ export interface AuthModule {
      * 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.
+     * - `'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. Enable SSO 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.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,17 @@ 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,
+            };
+        },
     };
 }

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,6 +20,17 @@ export type ConnectorIntegrationType = keyof ConnectorIntegrationTypeRegistry ex
  */
 export interface ConnectorAccessTokenResponse {
     access_token: string;
+    integration_type: string;
+    connection_config: Record<string, string> | null;
+}
+/**
+ * Camel-cased connection details returned by {@linkcode ConnectorsModule.getConnection | getConnection()}.
+ */
+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.
@@ -25,12 +42,20 @@ export interface ConnectorAccessTokenResponse {
  * the API calls you make. This is useful when you need custom API interactions that aren't
  * covered by Base44's pre-built integrations.
  *
+ * ## 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.
      *
+     * @deprecated Use {@link getConnection} and use the returned `accessToken` (and `connectionConfig` when needed) 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.
@@ -72,4 +97,41 @@ export interface ConnectorsModule {
      * ```
      */
     getAccessToken(integrationType: ConnectorIntegrationType): Promise<string>;
+    /**
+     * Retrieves the OAuth access token and connection configuration for a specific external integration type.
+     *
+     * Returns both the OAuth token and any additional connection configuration
+     * that the connector provides. This is useful when the external service requires
+     * extra parameters beyond the access token (e.g., a shop domain, account ID, or API base URL).
+     *
+     * @param integrationType - The type of integration, such as `'googlecalendar'`, `'slack'`, or `'github'`.
+     * @returns Promise resolving to a {@link ConnectorConnectionResponse} with `accessToken` and `connectionConfig`.
+     *
+     * @example
+     * ```typescript
+     * // Basic usage
+     * const connection = await base44.asServiceRole.connectors.getConnection('googlecalendar');
+     * console.log(connection.accessToken);
+     * console.log(connection.connectionConfig);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Shopify: connectionConfig has subdomain (e.g. "my-store" for my-store.myshopify.com)
+     * const connection = await base44.asServiceRole.connectors.getConnection('shopify');
+     * const { accessToken, connectionConfig } = connection;
+     * const shop = connectionConfig?.subdomain
+     *   ? `https://${connectionConfig.subdomain}.myshopify.com`
+     *   : null;
+     *
+     * if (shop) {
+     *   const response = await fetch(
+     *     `${shop}/admin/api/2024-01/products.json?limit=10`,
+     *     { headers: { 'X-Shopify-Access-Token': accessToken } }
+     *   );
+     *   const { products } = await response.json();
+     * }
+     * ```
+     */
+    getConnection(integrationType: ConnectorIntegrationType): Promise<ConnectorConnectionResponse>;
 }

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

@@ -27,16 +27,16 @@ 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;
 }
 /**
@@ -45,23 +45,26 @@ export interface DeleteManyResult {
  * @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 +74,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 +91,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;
@@ -401,17 +420,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-4'
  * });
  * ```
+ *
+ * @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;
@@ -324,6 +331,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 +340,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 +357,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-4'
+     * });
+     * ```
      */
     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-4'
+     * });
+     * ```
+     *
+     * @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.20",
   "description": "JavaScript SDK for Base44 API",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",