@depup/base44__sdk 0.8.22-depup.0

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

@@ -0,0 +1,103 @@
+/**
+ * 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 {
+}
+/**
+ * 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;
+/**
+ * Options for {@linkcode FunctionsModule.fetch}.
+ *
+ * Uses native `fetch` options directly.
+ */
+export type FunctionsFetchInit = RequestInit;
+/**
+ * Configuration for the functions module.
+ * @internal
+ */
+export interface FunctionsModuleConfig {
+    getAuthHeaders?: () => Record<string, string>;
+    baseURL?: string;
+}
+/**
+ * Functions module for invoking custom backend functions.
+ *
+ * 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 {
+    /**
+     * Invokes a custom backend function by name.
+     *
+     * Calls a custom backend function deployed to the app.
+     * The function receives the provided data as named parameters and returns
+     * the result. If any parameter is a `File` object, the request will automatically be
+     * sent as `multipart/form-data`. Otherwise, it will be sent as JSON.
+     *
+     * @param functionName - The name of the function to invoke.
+     * @param data - An object containing named parameters for the function.
+     * @returns Promise resolving to the function's response. The `data` property contains the data returned by the function, if there is any.
+     *
+     * @example
+     * ```typescript
+     * // Basic function call
+     * const result = await base44.functions.invoke('calculateTotal', {
+     *   items: ['item1', 'item2'],
+     * });
+     * console.log(result.data.total);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Function with file upload in React
+     * const handleFileUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (file) {
+     *     const processedImage = await base44.functions.invoke('processImage', {
+     *       image: file,
+     *       filter: 'grayscale',
+     *       quality: 80
+     *     });
+     *   }
+     * };
+     * ```
+     */
+    invoke(functionName: FunctionName, data?: Record<string, any>): Promise<any>;
+    /**
+     * Performs a direct HTTP request to a backend function path and returns the native `Response`.
+     *
+     * Use this method when you need low-level control over the request/response that the higher-level
+     * `invoke()` abstraction doesn't provide, such as:
+     * - Streaming responses (SSE, chunked text, NDJSON)
+     * - Custom HTTP methods (PUT, PATCH, DELETE, etc.)
+     * - Custom headers or request configuration
+     * - Access to raw response metadata (status, headers)
+     * - Direct control over request/response bodies
+     *
+     * Requests are sent to `/api/functions/<path>`.
+     *
+     * @param path - Function path, e.g. `/streaming_demo` or `/streaming_demo/deep/path`
+     * @param init - Native fetch options.
+     * @returns Promise resolving to a native fetch `Response`
+     */
+    fetch(path: string, init?: FunctionsFetchInit): Promise<Response>;
+}

package/dist/modules/functions.types.js

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

package/dist/modules/integrations.d.ts

@@ -0,0 +1,11 @@
+import { AxiosInstance } from "axios";
+import { IntegrationsModule } from "./integrations.types.js";
+/**
+ * Creates the integrations module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns Integrations module with dynamic access to integration endpoints
+ * @internal
+ */
+export declare function createIntegrationsModule(axios: AxiosInstance, appId: string): IntegrationsModule;

package/dist/modules/integrations.js

@@ -0,0 +1,77 @@
+import { createCustomIntegrationsModule } from "./custom-integrations.js";
+/**
+ * Creates the integrations module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @returns Integrations module with dynamic access to integration endpoints
+ * @internal
+ */
+export function createIntegrationsModule(axios, appId) {
+    // Create the custom integrations module once
+    const customModule = createCustomIntegrationsModule(axios, appId);
+    return new Proxy({}, {
+        get(target, packageName) {
+            // Skip internal properties
+            if (typeof packageName !== "string" ||
+                packageName === "then" ||
+                packageName.startsWith("_")) {
+                return undefined;
+            }
+            // Handle 'custom' specially - return the custom integrations module
+            if (packageName === "custom") {
+                return customModule;
+            }
+            // Create a proxy for integration endpoints
+            return new Proxy({}, {
+                get(target, endpointName) {
+                    // Skip internal properties
+                    if (typeof endpointName !== "string" ||
+                        endpointName === "then" ||
+                        endpointName.startsWith("_")) {
+                        return undefined;
+                    }
+                    // Return a function that calls the integration endpoint
+                    // This allows: client.integrations.PackageName.EndpointName(data)
+                    return async (data) => {
+                        // Validate input
+                        if (typeof data === "string") {
+                            throw new Error(`Integration ${endpointName} must receive an object with named parameters, received: ${data}`);
+                        }
+                        let formData;
+                        let contentType;
+                        // Handle file uploads with FormData
+                        if (data instanceof FormData ||
+                            (data &&
+                                Object.values(data).some((value) => value instanceof File))) {
+                            formData = new FormData();
+                            Object.keys(data).forEach((key) => {
+                                if (data[key] instanceof File) {
+                                    formData.append(key, data[key], data[key].name);
+                                }
+                                else if (typeof data[key] === "object" &&
+                                    data[key] !== null) {
+                                    formData.append(key, JSON.stringify(data[key]));
+                                }
+                                else {
+                                    formData.append(key, data[key]);
+                                }
+                            });
+                            contentType = "multipart/form-data";
+                        }
+                        else {
+                            formData = data;
+                            contentType = "application/json";
+                        }
+                        // For Core package
+                        if (packageName === "Core") {
+                            return axios.post(`/apps/${appId}/integration-endpoints/Core/${endpointName}`, formData || data, { headers: { "Content-Type": contentType } });
+                        }
+                        // For other packages
+                        return axios.post(`/apps/${appId}/integration-endpoints/installable/${packageName}/integration-endpoints/${endpointName}`, formData || data, { headers: { "Content-Type": contentType } });
+                    };
+                },
+            });
+        },
+    });
+}

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

@@ -0,0 +1,413 @@
+import { CustomIntegrationsModule } from "./custom-integrations.types.js";
+/**
+ * Function signature for calling an integration endpoint.
+ *
+ * If any parameter is a `File` object, the request will automatically be
+ * sent as `multipart/form-data`. Otherwise, it will be sent as JSON.
+ *
+ * @param data - An object containing named parameters for the integration endpoint.
+ * @returns Promise resolving to the integration endpoint's response.
+ */
+export type IntegrationEndpointFunction = (data: Record<string, any>) => Promise<any>;
+/**
+ * A package containing integration endpoints.
+ *
+ * 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 **Core package**
+ * ```typescript
+ * 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;
+};
+/**
+ * Parameters for the InvokeLLM function.
+ */
+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
+     */
+    add_context_from_internet?: boolean;
+    /** If you want structured data back, provide a [JSON schema object](https://json-schema.org/understanding-json-schema/reference/object) here. If provided, the function returns a JSON object; otherwise, it returns a string. */
+    response_json_schema?: object;
+    /** A list of file URLs (uploaded via UploadFile) to provide as context/attachments to the LLM. Do not use this together with `add_context_from_internet`. */
+    file_urls?: string[];
+}
+/**
+ * Parameters for the GenerateImage function.
+ */
+export interface GenerateImageParams {
+    /** Description of the image to generate. */
+    prompt: string;
+}
+export interface GenerateImageResult {
+    /** URL of the generated image. */
+    url: string;
+}
+/**
+ * Parameters for the UploadFile function.
+ */
+export interface UploadFileParams {
+    /** The file object to upload. */
+    file: File;
+}
+export interface UploadFileResult {
+    /** URL of the uploaded file. */
+    file_url: string;
+}
+/**
+ * Parameters for the SendEmail function.
+ */
+export interface SendEmailParams {
+    /** Recipient email address. */
+    to: string;
+    /** Email subject line. */
+    subject: string;
+    /** Plain text email body content. */
+    body: string;
+    /** The name of the sender. If omitted, the app's name will be used. */
+    from_name?: string;
+}
+export type SendEmailResult = any;
+/**
+ * Parameters for the ExtractDataFromUploadedFile function.
+ */
+export interface ExtractDataFromUploadedFileParams {
+    /** The URL of the uploaded file to extract data from. */
+    file_url: string;
+    /** A [JSON schema object](https://json-schema.org/understanding-json-schema/reference/object) defining what data fields you want to extract. */
+    json_schema: object;
+}
+export type ExtractDataFromUploadedFileResult = object;
+/**
+ * Parameters for the UploadPrivateFile function.
+ */
+export interface UploadPrivateFileParams {
+    /** The file object to upload. */
+    file: File;
+}
+export interface UploadPrivateFileResult {
+    /** URI of the uploaded private file, used to create a signed URL. */
+    file_uri: string;
+}
+/**
+ * Parameters for the CreateFileSignedUrl function.
+ */
+export interface CreateFileSignedUrlParams {
+    /** URI of the uploaded private file. */
+    file_uri: string;
+    /** How long the signed URL should be valid for, in seconds.
+     * @default 300 (5 minutes)
+     */
+    expires_in?: number;
+}
+export interface CreateFileSignedUrlResult {
+    /** Temporary signed URL to access the private file. */
+    signed_url: string;
+}
+/**
+ * Core package containing built-in Base44 integration functions.
+ */
+export interface CoreIntegrations {
+    /**
+     * Generate text or structured JSON data using AI models.
+     *
+     * @param params - Parameters for the LLM invocation
+     * @returns Promise resolving to a string (when no schema provided) or an object (when schema provided).
+     *
+     * @example
+     * ```typescript
+     * // Basic prompt
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: "Write a haiku about coding."
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Prompt with internet context
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: "What is the current stock price of Wix and what was the latest major news about it?",
+     *   add_context_from_internet: true
+     * });
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Structured JSON response
+     * const response = await base44.integrations.Core.InvokeLLM({
+     *   prompt: "Analyze the sentiment of this review: 'The service was slow but the food was amazing.'",
+     *   response_json_schema: {
+     *     type: "object",
+     *     properties: {
+     *       sentiment: { type: "string", enum: ["positive", "negative", "mixed"] },
+     *       score: { type: "number", description: "Score from 1-10" },
+     *       key_points: { type: "array", items: { type: "string" } }
+     *     }
+     *   }
+     * });
+     * // Returns object: { sentiment: "mixed", score: 7, key_points: ["slow service", "amazing food"] }
+     * ```
+     */
+    InvokeLLM(params: InvokeLLMParams): Promise<string | object>;
+    /**
+     * Create AI-generated images from text prompts.
+     *
+     * @param params - Parameters for image generation
+     * @returns Promise resolving to the generated image URL.
+     *
+     * @example
+     * ```typescript
+     * // Generate an image from a text prompt
+     * const {url} = await base44.integrations.Core.GenerateImage({
+     *   prompt: "A serene mountain landscape with a lake in the foreground"
+     * });
+     * console.log(url); // https://...generated_image.png
+     * ```
+     */
+    GenerateImage(params: GenerateImageParams): Promise<GenerateImageResult>;
+    /**
+     * Upload files to public storage and get a URL.
+     *
+     * @param params - Parameters for file upload
+     * @returns Promise resolving to an object containing the uploaded file URL.
+     *
+     * @example
+     * ```typescript
+     * // Upload a file in React
+     * const handleFileUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (!file) return;
+     *
+     *   const { file_url } = await base44.integrations.Core.UploadFile({ file });
+     *   console.log(file_url); // https://...uploaded_file.pdf
+     * };
+     * ```
+     */
+    UploadFile(params: UploadFileParams): Promise<UploadFileResult>;
+    /**
+     * Send emails to registered users of your app.
+     *
+     * @param params - Parameters for sending email
+     * @returns Promise resolving when the email is sent.
+     */
+    SendEmail(params: SendEmailParams): Promise<SendEmailResult>;
+    /**
+     * Extract structured data from uploaded files based on the specified schema.
+     *
+     * Start by uploading the file to public storage using the {@linkcode UploadFile | UploadFile()} function. Then, use the `file_url` parameter to extract structured data from the uploaded file.
+     *
+     * @param params - Parameters for data extraction
+     * @returns Promise resolving to the extracted data.
+     *
+     * @example
+     * ```typescript
+     * // Extract data from an already uploaded file
+     * const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
+     *   file_url: "https://example.com/files/invoice.pdf",
+     *   json_schema: {
+     *     type: "object",
+     *     properties: {
+     *       invoice_number: { type: "string" },
+     *       total_amount: { type: "number" },
+     *       date: { type: "string" },
+     *       vendor_name: { type: "string" }
+     *     }
+     *   }
+     * });
+     * console.log(result); // { invoice_number: "INV-12345", total_amount: 1250.00, ... }
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Upload a file and extract data in React
+     * const handleFileExtraction = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (!file) return;
+     *
+     *   // First, upload the file
+     *   const { file_url } = await base44.integrations.Core.UploadFile({ file });
+     *
+     *   // Then extract structured data from it
+     *   const result = await base44.integrations.Core.ExtractDataFromUploadedFile({
+     *     file_url,
+     *     json_schema: {
+     *       type: "object",
+     *       properties: {
+     *         summary: {
+     *           type: "string",
+     *           description: "A brief summary of the file content"
+     *         },
+     *         keywords: {
+     *           type: "array",
+     *           items: { type: "string" }
+     *         },
+     *         document_type: {
+     *           type: "string"
+     *         }
+     *       }
+     *     }
+     *   });
+     *   console.log(result); // { summary: "...", keywords: [...], document_type: "..." }
+     * };
+     * ```
+     */
+    ExtractDataFromUploadedFile(params: ExtractDataFromUploadedFileParams): Promise<ExtractDataFromUploadedFileResult>;
+    /**
+     * Upload files to private storage that requires a signed URL to access.
+     *
+     * Create a signed URL to access uploaded files using the {@linkcode CreateFileSignedUrl | CreateFileSignedUrl()} function.
+     *
+     * @param params - Parameters for private file upload
+     * @returns Promise resolving to an object with a `file_uri` used to create a signed URL to access the uploaded file.
+     *
+     * @example
+     * ```typescript
+     * // Upload a private file
+     * const { file_uri } = await base44.integrations.Core.UploadPrivateFile({ file });
+     * console.log(file_uri); // "private/user123/document.pdf"
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Upload a private file and create a signed URL
+     * const handlePrivateUpload = async (event: React.ChangeEvent<HTMLInputElement>) => {
+     *   const file = event.target.files?.[0];
+     *   if (!file) return;
+     *
+     *   // Upload to private storage
+     *   const { file_uri } = await base44.integrations.Core.UploadPrivateFile({ file });
+     *
+     *   // Create a signed URL that expires in 1 hour (3600 seconds)
+     *   const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
+     *     file_uri,
+     *     expires_in: 3600
+     *   });
+     *
+     *   console.log(signed_url); // Temporary URL to access the private file
+     * };
+     * ```
+     */
+    UploadPrivateFile(params: UploadPrivateFileParams): Promise<UploadPrivateFileResult>;
+    /**
+     * Generate temporary access links for private files.
+     *
+     * Start by uploading the file to private storage using the {@linkcode UploadPrivateFile | UploadPrivateFile()} function. Then, use the `file_uri` parameter to create a signed URL to access the uploaded file.
+     *
+     * @param params - Parameters for creating signed URL
+     * @returns Promise resolving to an object with a temporary `signed_url`.
+     *
+     * @example
+     * ```typescript
+     * // Create a signed URL for a private file
+     * const { signed_url } = await base44.integrations.Core.CreateFileSignedUrl({
+     *   file_uri: "private/user123/document.pdf",
+     *   expires_in: 7200 // URL expires in 2 hours
+     * });
+     * console.log(signed_url); // https://...?signature=...
+     * ```
+     */
+    CreateFileSignedUrl(params: CreateFileSignedUrlParams): Promise<CreateFileSignedUrlResult>;
+}
+/**
+ * Integrations module for calling integration methods.
+ *
+ * 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:
+ *   ```
+ *   base44.integrations.Core.FunctionName(params)
+ *   ```
+ *
+ * - **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 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:
+ *
+ * - **Anonymous or User authentication** (`base44.integrations`): Integration methods are invoked with the current user's permissions. Anonymous users invoke methods without authentication, while authenticated users invoke methods with their authentication context.
+ * - **Service role authentication** (`base44.asServiceRole.integrations`): Integration methods are invoked with elevated admin-level permissions. The methods execute with admin authentication context.
+ */
+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;
+    /**
+     * 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.
+     *
+     * 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/dist/modules/integrations.types.js

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

package/dist/modules/sso.d.ts

@@ -0,0 +1,12 @@
+import { AxiosInstance } from "axios";
+import { SsoModule } from "./sso.types";
+/**
+ * Creates the SSO module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @param userToken - User authentication token
+ * @returns SSO module with authentication methods
+ * @internal
+ */
+export declare function createSsoModule(axios: AxiosInstance, appId: string, userToken?: string): SsoModule;

package/dist/modules/sso.js

@@ -0,0 +1,23 @@
+/**
+ * Creates the SSO module for the Base44 SDK.
+ *
+ * @param axios - Axios instance
+ * @param appId - Application ID
+ * @param userToken - User authentication token
+ * @returns SSO module with authentication methods
+ * @internal
+ */
+export function createSsoModule(axios, appId, userToken) {
+    return {
+        // Get SSO access token for a specific user
+        async getAccessToken(userid) {
+            const url = `/apps/${appId}/auth/sso/accesstoken/${userid}`;
+            // Prepare headers with both tokens if available
+            const headers = {};
+            if (userToken) {
+                headers["on-behalf-of"] = `Bearer ${userToken}`;
+            }
+            return axios.get(url, { headers });
+        },
+    };
+}