@depup/base44__sdk 0.8.22-depup.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 base44
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,32 @@
+# @depup/base44__sdk
+
+> Dependency-bumped version of [@base44/sdk](https://www.npmjs.com/package/@base44/sdk)
+
+Generated by [DepUp](https://github.com/depup/npm) -- all production
+dependencies bumped to latest versions.
+
+## Installation
+
+```bash
+npm install @depup/base44__sdk
+```
+
+| Field | Value |
+|-------|-------|
+| Original | [@base44/sdk](https://www.npmjs.com/package/@base44/sdk) @ 0.8.22 |
+| Processed | 2026-03-17 |
+| Smoke test | passed |
+| Deps updated | 2 |
+
+## Dependency Changes
+
+| Dependency | From | To |
+|------------|------|-----|
+| axios | ^1.6.2 | ^1.13.6 |
+| socket.io-client | ^4.7.5 | ^4.8.3 |
+
+---
+
+Source: https://github.com/depup/npm | Original: https://www.npmjs.com/package/@base44/sdk
+
+License inherited from the original package.

package/changes.json

@@ -0,0 +1,14 @@
+{
+  "bumped": {
+    "axios": {
+      "from": "^1.6.2",
+      "to": "^1.13.6"
+    },
+    "socket.io-client": {
+      "from": "^4.7.5",
+      "to": "^4.8.3"
+    }
+  },
+  "timestamp": "2026-03-17T16:30:57.506Z",
+  "totalUpdated": 2
+}

package/dist/client.d.ts

@@ -0,0 +1,96 @@
+import type { Base44Client, CreateClientConfig, CreateClientOptions } from "./client.types.js";
+export type { Base44Client, CreateClientConfig, CreateClientOptions };
+/**
+ * Creates a Base44 client.
+ *
+ * This is the main entry point for the Base44 SDK. It creates a client that provides access to the SDK's modules, such as {@linkcode EntitiesModule | entities}, {@linkcode AuthModule | auth}, and {@linkcode FunctionsModule | functions}.
+ *
+ * How you get a client depends on your context:
+ * - **Inside a Base44 app:** The client is automatically created and configured for you. Import it from `@/api/base44Client`.
+ * - **External app using Base44 as a backend:** Call `createClient()` directly in your code to create and configure the client.
+ *
+ * The client supports three authentication modes:
+ * - **Anonymous**: Access modules without authentication using `base44.moduleName`. Operations are scoped to public data and permissions.
+ * - **User authentication**: Access modules with user-level permissions using `base44.moduleName`. Operations are scoped to the authenticated user's data and permissions. Use `base44.auth.loginViaEmailPassword()` or other auth methods to get a token.
+ * - **Service role authentication**: Access modules with elevated permissions using `base44.asServiceRole.moduleName`. Operations can access any data available to the app's admin. Only available in Base44-hosted backend functions. Create a client with service role authentication using {@linkcode createClientFromRequest | createClientFromRequest()}.
+ *
+ * For example, when using the {@linkcode EntitiesModule | entities} module:
+ * - **Anonymous**: Can only read public data.
+ * - **User authentication**: Can access the current user's data.
+ * - **Service role authentication**: Can access all data that admins can access.
+ *
+ * Most modules are available in all three modes, but with different permission levels. However, some modules are only available in specific authentication modes.
+ *
+ * @param config - Configuration object for the client.
+ * @returns A configured Base44 client instance with access to all SDK modules.
+ *
+ * @example
+ * ```typescript
+ * // Create a client for your app
+ * import { createClient } from '@base44/sdk';
+ *
+ * const base44 = createClient({
+ *   appId: 'my-app-id'
+ * });
+ *
+ * // Use the client to access your data
+ * const products = await base44.entities.Products.list();
+ * ```
+ */
+export declare function createClient(config: CreateClientConfig): Base44Client;
+/**
+ * Creates a Base44 client from an HTTP request.
+ *
+ * This function is designed for use in Base44-hosted backend functions. For frontends and external backends, use {@linkcode createClient | createClient()} instead.
+ *
+ * When used in a Base44-hosted backend function, `createClientFromRequest()` automatically extracts authentication tokens from the request headers that Base44 injects when forwarding requests. The returned client includes service role access using `base44.asServiceRole`, which provides admin-level permissions.
+ *
+ * To learn more about the Base44 client, see {@linkcode createClient | createClient()}.
+ *
+ * @param request - The incoming HTTP request object containing Base44 authentication headers.
+ * @returns A configured Base44 client instance with authentication from the incoming request.
+ *
+ * @example
+ * ```typescript
+ * // User authentication in backend function
+ * import { createClientFromRequest } from 'npm:@base44/sdk';
+ *
+ * Deno.serve(async (req) => {
+ *   try {
+ *     const base44 = createClientFromRequest(req);
+ *     const user = await base44.auth.me();
+ *
+ *     if (!user) {
+ *       return Response.json({ error: 'Unauthorized' }, { status: 401 });
+ *     }
+ *
+ *     // Access user's data
+ *     const userOrders = await base44.entities.Orders.filter({ userId: user.id });
+ *     return Response.json({ orders: userOrders });
+ *   } catch (error) {
+ *     return Response.json({ error: error.message }, { status: 500 });
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Service role authentication in backend function
+ * import { createClientFromRequest } from 'npm:@base44/sdk';
+ *
+ * Deno.serve(async (req) => {
+ *   try {
+ *     const base44 = createClientFromRequest(req);
+ *
+ *     // Access admin data with service role permissions
+ *     const recentOrders = await base44.asServiceRole.entities.Orders.list('-created_at', 50);
+ *
+ *     return Response.json({ orders: recentOrders });
+ *   } catch (error) {
+ *     return Response.json({ error: error.message }, { status: 500 });
+ *   }
+ * });
+ * ```
+ *
+ */
+export declare function createClientFromRequest(request: Request): Base44Client;

package/dist/client.js

@@ -0,0 +1,375 @@
+import { createAxiosClient } from "./utils/axios-client.js";
+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, createUserConnectorsModule, } from "./modules/connectors.js";
+import { getAccessToken } from "./utils/auth-utils.js";
+import { createFunctionsModule } from "./modules/functions.js";
+import { createAgentsModule } from "./modules/agents.js";
+import { createAppLogsModule } from "./modules/app-logs.js";
+import { createUsersModule } from "./modules/users.js";
+import { RoomsSocket } from "./utils/socket-utils.js";
+import { createAnalyticsModule } from "./modules/analytics.js";
+/**
+ * Creates a Base44 client.
+ *
+ * This is the main entry point for the Base44 SDK. It creates a client that provides access to the SDK's modules, such as {@linkcode EntitiesModule | entities}, {@linkcode AuthModule | auth}, and {@linkcode FunctionsModule | functions}.
+ *
+ * How you get a client depends on your context:
+ * - **Inside a Base44 app:** The client is automatically created and configured for you. Import it from `@/api/base44Client`.
+ * - **External app using Base44 as a backend:** Call `createClient()` directly in your code to create and configure the client.
+ *
+ * The client supports three authentication modes:
+ * - **Anonymous**: Access modules without authentication using `base44.moduleName`. Operations are scoped to public data and permissions.
+ * - **User authentication**: Access modules with user-level permissions using `base44.moduleName`. Operations are scoped to the authenticated user's data and permissions. Use `base44.auth.loginViaEmailPassword()` or other auth methods to get a token.
+ * - **Service role authentication**: Access modules with elevated permissions using `base44.asServiceRole.moduleName`. Operations can access any data available to the app's admin. Only available in Base44-hosted backend functions. Create a client with service role authentication using {@linkcode createClientFromRequest | createClientFromRequest()}.
+ *
+ * For example, when using the {@linkcode EntitiesModule | entities} module:
+ * - **Anonymous**: Can only read public data.
+ * - **User authentication**: Can access the current user's data.
+ * - **Service role authentication**: Can access all data that admins can access.
+ *
+ * Most modules are available in all three modes, but with different permission levels. However, some modules are only available in specific authentication modes.
+ *
+ * @param config - Configuration object for the client.
+ * @returns A configured Base44 client instance with access to all SDK modules.
+ *
+ * @example
+ * ```typescript
+ * // Create a client for your app
+ * import { createClient } from '@base44/sdk';
+ *
+ * const base44 = createClient({
+ *   appId: 'my-app-id'
+ * });
+ *
+ * // Use the client to access your data
+ * const products = await base44.entities.Products.list();
+ * ```
+ */
+export function createClient(config) {
+    var _a, _b;
+    const { serverUrl = "https://base44.app", appId, token, serviceToken, requiresAuth = false, appBaseUrl, options, functionsVersion, headers: optionalHeaders, } = config;
+    // Normalize appBaseUrl to always be a string (empty if not provided or invalid)
+    const normalizedAppBaseUrl = typeof appBaseUrl === "string" ? appBaseUrl : "";
+    const socketConfig = {
+        serverUrl,
+        mountPath: "/ws-user-apps/socket.io/",
+        transports: ["websocket"],
+        appId,
+        token,
+    };
+    let socket = null;
+    const getSocket = () => {
+        if (!socket) {
+            socket = RoomsSocket({
+                config: socketConfig,
+            });
+        }
+        return socket;
+    };
+    const headers = {
+        ...optionalHeaders,
+        "X-App-Id": String(appId),
+    };
+    const functionHeaders = functionsVersion
+        ? {
+            ...headers,
+            "Base44-Functions-Version": functionsVersion,
+        }
+        : headers;
+    const axiosClient = createAxiosClient({
+        baseURL: `${serverUrl}/api`,
+        headers,
+        token,
+        onError: options === null || options === void 0 ? void 0 : options.onError,
+    });
+    const functionsAxiosClient = createAxiosClient({
+        baseURL: `${serverUrl}/api`,
+        headers: functionHeaders,
+        token,
+        interceptResponses: false,
+        onError: options === null || options === void 0 ? void 0 : options.onError,
+    });
+    const serviceRoleAxiosClient = createAxiosClient({
+        baseURL: `${serverUrl}/api`,
+        headers,
+        token: serviceToken,
+        onError: options === null || options === void 0 ? void 0 : options.onError,
+    });
+    const serviceRoleFunctionsAxiosClient = createAxiosClient({
+        baseURL: `${serverUrl}/api`,
+        headers: functionHeaders,
+        token: serviceToken,
+        interceptResponses: false,
+    });
+    const userAuthModule = createAuthModule(axiosClient, functionsAxiosClient, appId, {
+        appBaseUrl: normalizedAppBaseUrl,
+        serverUrl,
+    });
+    const userModules = {
+        entities: createEntitiesModule({
+            axios: axiosClient,
+            appId,
+            getSocket,
+        }),
+        integrations: createIntegrationsModule(axiosClient, appId),
+        connectors: createUserConnectorsModule(axiosClient, appId),
+        auth: userAuthModule,
+        functions: createFunctionsModule(functionsAxiosClient, appId, {
+            getAuthHeaders: () => {
+                const headers = {};
+                // Get current token from storage or initial config
+                const currentToken = token || getAccessToken();
+                if (currentToken) {
+                    headers["Authorization"] = `Bearer ${currentToken}`;
+                }
+                return headers;
+            },
+            baseURL: (_a = functionsAxiosClient.defaults) === null || _a === void 0 ? void 0 : _a.baseURL,
+        }),
+        agents: createAgentsModule({
+            axios: axiosClient,
+            getSocket,
+            appId,
+            serverUrl,
+            token,
+        }),
+        appLogs: createAppLogsModule(axiosClient, appId),
+        users: createUsersModule(axiosClient, appId),
+        analytics: createAnalyticsModule({
+            axiosClient,
+            serverUrl,
+            appId,
+            userAuthModule,
+        }),
+        cleanup: () => {
+            userModules.analytics.cleanup();
+            if (socket) {
+                socket.disconnect();
+            }
+        },
+    };
+    const serviceRoleModules = {
+        entities: createEntitiesModule({
+            axios: serviceRoleAxiosClient,
+            appId,
+            getSocket,
+        }),
+        integrations: createIntegrationsModule(serviceRoleAxiosClient, appId),
+        sso: createSsoModule(serviceRoleAxiosClient, appId, token),
+        connectors: createConnectorsModule(serviceRoleAxiosClient, appId),
+        functions: createFunctionsModule(serviceRoleFunctionsAxiosClient, appId, {
+            getAuthHeaders: () => {
+                const headers = {};
+                // Use service token for authorization
+                if (serviceToken) {
+                    headers["Authorization"] = `Bearer ${serviceToken}`;
+                }
+                return headers;
+            },
+            baseURL: (_b = serviceRoleFunctionsAxiosClient.defaults) === null || _b === void 0 ? void 0 : _b.baseURL,
+        }),
+        agents: createAgentsModule({
+            axios: serviceRoleAxiosClient,
+            getSocket,
+            appId,
+            serverUrl,
+            token,
+        }),
+        appLogs: createAppLogsModule(serviceRoleAxiosClient, appId),
+        cleanup: () => {
+            if (socket) {
+                socket.disconnect();
+            }
+        },
+    };
+    // Always try to get token from localStorage or URL parameters
+    if (typeof window !== "undefined") {
+        // Get token from URL or localStorage
+        const accessToken = token || getAccessToken();
+        if (accessToken) {
+            userModules.auth.setToken(accessToken);
+        }
+    }
+    // If authentication is required, verify token and redirect to login if needed
+    if (requiresAuth && typeof window !== "undefined") {
+        // We perform this check asynchronously to not block client creation
+        setTimeout(async () => {
+            try {
+                const isAuthenticated = await userModules.auth.isAuthenticated();
+                if (!isAuthenticated) {
+                    userModules.auth.redirectToLogin(window.location.href);
+                }
+            }
+            catch (error) {
+                console.error("Authentication check failed:", error);
+                userModules.auth.redirectToLogin(window.location.href);
+            }
+        }, 0);
+    }
+    // Assemble and return the client
+    const client = {
+        ...userModules,
+        /**
+         * Sets a new authentication token for all subsequent requests.
+         *
+         * @param newToken - The new authentication token
+         *
+         * @example
+         * ```typescript
+         * // Update token after login
+         * const { access_token } = await base44.auth.loginViaEmailPassword(
+         *   'user@example.com',
+         *   'password'
+         * );
+         * base44.setToken(access_token);
+         * ```
+         */
+        setToken(newToken) {
+            userModules.auth.setToken(newToken);
+            if (socket) {
+                socket.updateConfig({
+                    token: newToken,
+                });
+            }
+            socketConfig.token = newToken;
+        },
+        /**
+         * Gets the current client configuration.
+         *
+         * @internal
+         */
+        getConfig() {
+            return {
+                serverUrl,
+                appId,
+                requiresAuth,
+            };
+        },
+        /**
+         * Provides access to service role modules.
+         *
+         * Service role authentication provides elevated permissions for backend operations. Unlike user authentication, which is scoped to a specific user's permissions, service role authentication has access to the data and operations available to the app's admin.
+         *
+         * @throws {Error} When accessed without providing a serviceToken during client creation.
+         *
+         * @example
+         * ```typescript
+         * const base44 = createClient({
+         *   appId: 'my-app-id',
+         *   serviceToken: 'service-role-token'
+         * });
+         *
+         * // Also access a module with elevated permissions
+         * const allUsers = await base44.asServiceRole.entities.User.list();
+         * ```
+         */
+        get asServiceRole() {
+            if (!serviceToken) {
+                throw new Error("Service token is required to use asServiceRole. Please provide a serviceToken when creating the client.");
+            }
+            return serviceRoleModules;
+        },
+    };
+    return client;
+}
+/**
+ * Creates a Base44 client from an HTTP request.
+ *
+ * This function is designed for use in Base44-hosted backend functions. For frontends and external backends, use {@linkcode createClient | createClient()} instead.
+ *
+ * When used in a Base44-hosted backend function, `createClientFromRequest()` automatically extracts authentication tokens from the request headers that Base44 injects when forwarding requests. The returned client includes service role access using `base44.asServiceRole`, which provides admin-level permissions.
+ *
+ * To learn more about the Base44 client, see {@linkcode createClient | createClient()}.
+ *
+ * @param request - The incoming HTTP request object containing Base44 authentication headers.
+ * @returns A configured Base44 client instance with authentication from the incoming request.
+ *
+ * @example
+ * ```typescript
+ * // User authentication in backend function
+ * import { createClientFromRequest } from 'npm:@base44/sdk';
+ *
+ * Deno.serve(async (req) => {
+ *   try {
+ *     const base44 = createClientFromRequest(req);
+ *     const user = await base44.auth.me();
+ *
+ *     if (!user) {
+ *       return Response.json({ error: 'Unauthorized' }, { status: 401 });
+ *     }
+ *
+ *     // Access user's data
+ *     const userOrders = await base44.entities.Orders.filter({ userId: user.id });
+ *     return Response.json({ orders: userOrders });
+ *   } catch (error) {
+ *     return Response.json({ error: error.message }, { status: 500 });
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Service role authentication in backend function
+ * import { createClientFromRequest } from 'npm:@base44/sdk';
+ *
+ * Deno.serve(async (req) => {
+ *   try {
+ *     const base44 = createClientFromRequest(req);
+ *
+ *     // Access admin data with service role permissions
+ *     const recentOrders = await base44.asServiceRole.entities.Orders.list('-created_at', 50);
+ *
+ *     return Response.json({ orders: recentOrders });
+ *   } catch (error) {
+ *     return Response.json({ error: error.message }, { status: 500 });
+ *   }
+ * });
+ * ```
+ *
+ */
+export function createClientFromRequest(request) {
+    const authHeader = request.headers.get("Authorization");
+    const serviceRoleAuthHeader = request.headers.get("Base44-Service-Authorization");
+    const appId = request.headers.get("Base44-App-Id");
+    const serverUrlHeader = request.headers.get("Base44-Api-Url");
+    const functionsVersion = request.headers.get("Base44-Functions-Version");
+    const stateHeader = request.headers.get("Base44-State");
+    if (!appId) {
+        throw new Error("Base44-App-Id header is required, but is was not found on the request");
+    }
+    // Validate authorization header formats
+    let serviceRoleToken;
+    let userToken;
+    if (serviceRoleAuthHeader !== null) {
+        if (serviceRoleAuthHeader === "" ||
+            !serviceRoleAuthHeader.startsWith("Bearer ") ||
+            serviceRoleAuthHeader.split(" ").length !== 2) {
+            throw new Error('Invalid authorization header format. Expected "Bearer <token>"');
+        }
+        serviceRoleToken = serviceRoleAuthHeader.split(" ")[1];
+    }
+    if (authHeader !== null) {
+        if (authHeader === "" ||
+            !authHeader.startsWith("Bearer ") ||
+            authHeader.split(" ").length !== 2) {
+            throw new Error('Invalid authorization header format. Expected "Bearer <token>"');
+        }
+        userToken = authHeader.split(" ")[1];
+    }
+    // Prepare additional headers to propagate
+    const additionalHeaders = {};
+    if (stateHeader) {
+        additionalHeaders["Base44-State"] = stateHeader;
+    }
+    return createClient({
+        serverUrl: serverUrlHeader || "https://base44.app",
+        appId,
+        token: userToken,
+        serviceToken: serviceRoleToken,
+        functionsVersion: functionsVersion !== null && functionsVersion !== void 0 ? functionsVersion : undefined,
+        headers: additionalHeaders,
+    });
+}

package/dist/client.types.d.ts

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

package/dist/client.types.js

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