@blocksdiy/blocks-client-sdk 1.0.0

package/README.md

@@ -0,0 +1 @@
+# blocks-client-sdk.

package/dist/Action.d.ts

@@ -0,0 +1,142 @@
+/**
+ * Configuration for defining an action
+ *
+ * This interface is used to define the structure of an action, including
+ * its input parameters and output format.
+ *
+ * @interface ActionConfig
+ * @template IT - Type defining the structure of the action's input
+ * @template OT - Type defining the structure of the action's output
+ * @property {string} actionBlockId - Unique identifier for the action workflow
+ * @property {string} toolSetId - Unique identifier for the tool set
+ * @property {string} toolId - Unique identifier for the tool
+ * @property {IT} inputInstanceType - Type definition object for the action's input parameters
+ * @property {OT} outputInstanceType - Type definition object for the action's output structure
+ */
+export interface ActionConfig<IT extends Record<string, unknown> = {}, OT extends Record<string, unknown> = {}> {
+    actionBlockId: string;
+    toolSetId?: string;
+    toolId?: string;
+    inputInstanceType: IT;
+    outputInstanceType: OT;
+}
+/**
+ * Action class for executing server-side workflows
+ *
+ * This class provides methods to execute various server-side operations defined as actions.
+ * Actions can perform any type of server-side logic, such as data processing, integrations
+ * with external services, business logic, and AI operations.
+ *
+ * @class Action
+ * @template AC - Action configuration type
+ */
+export declare class Action<AC extends ActionConfig = ActionConfig> {
+    private actionBlockId;
+    private appId;
+    private toolSetId?;
+    private toolId?;
+    private onError?;
+    private token?;
+    /**
+     * Creates a new Action instance
+     * @param {AC} config - Configuration for the action
+     */
+    constructor(config: AC, { appId, onError, token }: {
+        appId: string;
+        onError?: (error: Error) => void;
+        token?: string;
+    });
+    /**
+     * Executes the action with the provided input
+     *
+     * Sends the input to the server-side workflow and returns the result.
+     * Supports streaming responses through the onChunk callback.
+     *
+     * @param {AC["inputInstanceType"]} input - Input parameters for the action
+     * @param {Object} options - Execution options
+     * @param {Function} [options.onChunk] - Optional callback for handling streaming chunks
+     * @returns {Promise<AC["outputInstanceType"]>} The action result
+     * @example
+     * ```ts
+     * // Example 1: Data processing action
+     * const processOrderConfig = {
+     *   actionBlockId: 'process-order-id',
+     *   inputInstanceType: {} as {
+     *     orderId: string;
+     *     userId: string;
+     *     items: Array<{ productId: string; quantity: number }>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     success: boolean;
+     *     orderNumber: string;
+     *     estimatedDelivery: string;
+     *   }
+     * };
+     *
+     * const orderAction = new Action(processOrderConfig);
+     * const result = await orderAction.execute({
+     *   orderId: 'order-123',
+     *   userId: 'user-456',
+     *   items: [{ productId: 'prod-789', quantity: 2 }]
+     * });
+     *
+     * console.log(`Order processed: ${result.orderNumber}`);
+     *
+     * // Example 2: Integration with external service
+     * const sendEmailConfig = {
+     *   actionBlockId: 'send-email-id',
+     *   inputInstanceType: {} as {
+     *     to: string;
+     *     subject: string;
+     *     body: string;
+     *     attachments?: Array<{ name: string; url: string }>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     sent: boolean;
+     *     messageId?: string;
+     *     error?: string;
+     *   }
+     * };
+     *
+     * const emailAction = new Action(sendEmailConfig);
+     * const emailResult = await emailAction.execute({
+     *   to: 'user@example.com',
+     *   subject: 'Welcome to our platform',
+     *   body: 'Thank you for signing up!'
+     * });
+     *
+     * // Example 3: Action with streaming response
+     * const generateReportConfig = {
+     *   actionBlockId: 'generate-report-id',
+     *   inputInstanceType: {} as {
+     *     type: 'sales' | 'inventory';
+     *     period: 'daily' | 'weekly' | 'monthly';
+     *     filters: Record<string, any>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     reportUrl: string;
+     *     summary: string;
+     *   }
+     * };
+     *
+     * const reportAction = new Action(generateReportConfig);
+     * const reportResult = await reportAction.execute(
+     *   {
+     *     type: 'sales',
+     *     period: 'monthly',
+     *     filters: { region: 'north-america' }
+     *   },
+     *   {
+     *     onChunk: (chunk) => {
+     *       // Display progress updates to the user
+     *       console.log(`Report generation: ${chunk.progress}%`);
+     *     }
+     *   }
+     * );
+     * ```
+     */
+    execute(input: AC["inputInstanceType"], { onChunk }?: {
+        onChunk?: (chunk: any) => void;
+    }): Promise<AC["outputInstanceType"]>;
+}
+//# sourceMappingURL=Action.d.ts.map

package/dist/Action.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.d.ts","sourceRoot":"","sources":["../src/Action.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,YAAY,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE,EAAE,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,EAAE;IAC5G,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,iBAAiB,EAAE,EAAE,CAAC;IACtB,kBAAkB,EAAE,EAAE,CAAC;CACxB;AAED;;;;;;;;;GASG;AACH,qBAAa,MAAM,CAAC,EAAE,SAAS,YAAY,GAAG,YAAY;IACxD,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,SAAS,CAAC,CAAS;IAC3B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,OAAO,CAAC,CAAyB;IACzC,OAAO,CAAC,KAAK,CAAC,CAAS;IACvB;;;OAGG;gBAED,MAAM,EAAE,EAAE,EACV,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAUhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwFG;IACG,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,mBAAmB,CAAC,EAAE,EAAE,OAAO,EAAE,GAAE;QAAE,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,IAAI,CAAA;KAAO;CAuBnG"}

package/dist/Action.js

@@ -0,0 +1,143 @@
+import { WorkflowRequest } from "@blockscom/blocks-client-api/workflowService";
+/**
+ * Action class for executing server-side workflows
+ *
+ * This class provides methods to execute various server-side operations defined as actions.
+ * Actions can perform any type of server-side logic, such as data processing, integrations
+ * with external services, business logic, and AI operations.
+ *
+ * @class Action
+ * @template AC - Action configuration type
+ */
+export class Action {
+    actionBlockId;
+    appId;
+    toolSetId;
+    toolId;
+    onError;
+    token;
+    /**
+     * Creates a new Action instance
+     * @param {AC} config - Configuration for the action
+     */
+    constructor(config, { appId, onError, token }) {
+        this.actionBlockId = config.actionBlockId;
+        this.appId = appId;
+        this.toolSetId = config.toolSetId;
+        this.toolId = config.toolId;
+        this.onError = onError;
+        this.token = token;
+    }
+    /**
+     * Executes the action with the provided input
+     *
+     * Sends the input to the server-side workflow and returns the result.
+     * Supports streaming responses through the onChunk callback.
+     *
+     * @param {AC["inputInstanceType"]} input - Input parameters for the action
+     * @param {Object} options - Execution options
+     * @param {Function} [options.onChunk] - Optional callback for handling streaming chunks
+     * @returns {Promise<AC["outputInstanceType"]>} The action result
+     * @example
+     * ```ts
+     * // Example 1: Data processing action
+     * const processOrderConfig = {
+     *   actionBlockId: 'process-order-id',
+     *   inputInstanceType: {} as {
+     *     orderId: string;
+     *     userId: string;
+     *     items: Array<{ productId: string; quantity: number }>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     success: boolean;
+     *     orderNumber: string;
+     *     estimatedDelivery: string;
+     *   }
+     * };
+     *
+     * const orderAction = new Action(processOrderConfig);
+     * const result = await orderAction.execute({
+     *   orderId: 'order-123',
+     *   userId: 'user-456',
+     *   items: [{ productId: 'prod-789', quantity: 2 }]
+     * });
+     *
+     * console.log(`Order processed: ${result.orderNumber}`);
+     *
+     * // Example 2: Integration with external service
+     * const sendEmailConfig = {
+     *   actionBlockId: 'send-email-id',
+     *   inputInstanceType: {} as {
+     *     to: string;
+     *     subject: string;
+     *     body: string;
+     *     attachments?: Array<{ name: string; url: string }>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     sent: boolean;
+     *     messageId?: string;
+     *     error?: string;
+     *   }
+     * };
+     *
+     * const emailAction = new Action(sendEmailConfig);
+     * const emailResult = await emailAction.execute({
+     *   to: 'user@example.com',
+     *   subject: 'Welcome to our platform',
+     *   body: 'Thank you for signing up!'
+     * });
+     *
+     * // Example 3: Action with streaming response
+     * const generateReportConfig = {
+     *   actionBlockId: 'generate-report-id',
+     *   inputInstanceType: {} as {
+     *     type: 'sales' | 'inventory';
+     *     period: 'daily' | 'weekly' | 'monthly';
+     *     filters: Record<string, any>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     reportUrl: string;
+     *     summary: string;
+     *   }
+     * };
+     *
+     * const reportAction = new Action(generateReportConfig);
+     * const reportResult = await reportAction.execute(
+     *   {
+     *     type: 'sales',
+     *     period: 'monthly',
+     *     filters: { region: 'north-america' }
+     *   },
+     *   {
+     *     onChunk: (chunk) => {
+     *       // Display progress updates to the user
+     *       console.log(`Report generation: ${chunk.progress}%`);
+     *     }
+     *   }
+     * );
+     * ```
+     */
+    async execute(input, { onChunk } = {}) {
+        const result = await WorkflowRequest.run({
+            workflowBlockId: this.actionBlockId,
+            appId: this.appId,
+            token: this.token,
+            input: {
+                ...input,
+                toolId: this.toolId,
+            },
+            context: {
+                appId: this.appId,
+                toolSetId: this.toolSetId,
+            },
+            onChunk: (data) => {
+                onChunk?.(data);
+            },
+            onFailed: (error) => {
+                this.onError?.(error);
+            },
+        });
+        return result;
+    }
+}
+//# sourceMappingURL=Action.js.map

package/dist/Action.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Action.js","sourceRoot":"","sources":["../src/Action.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,8CAA8C,CAAC;AAyB/E;;;;;;;;;GASG;AACH,MAAM,OAAO,MAAM;IACT,aAAa,CAAS;IACtB,KAAK,CAAS;IACd,SAAS,CAAU;IACnB,MAAM,CAAU;IAChB,OAAO,CAA0B;IACjC,KAAK,CAAU;IACvB;;;OAGG;IACH,YACE,MAAU,EACV,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAuE;QAE9F,IAAI,CAAC,aAAa,GAAG,MAAM,CAAC,aAAa,CAAC;QAC1C,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,SAAS,GAAG,MAAM,CAAC,SAAS,CAAC;QAClC,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC5B,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwFG;IACH,KAAK,CAAC,OAAO,CAAC,KAA8B,EAAE,EAAE,OAAO,KAAyC,EAAE;QAChG,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,GAAG,CAAC;YACvC,eAAe,EAAE,IAAI,CAAC,aAAa;YACnC,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE;gBACL,GAAG,KAAK;gBACR,MAAM,EAAE,IAAI,CAAC,MAAM;aACpB;YACD,OAAO,EAAE;gBACP,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,SAAS,EAAE,IAAI,CAAC,SAAS;aAC1B;YACD,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;gBAChB,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;YAClB,CAAC;YACD,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE;gBAClB,IAAI,CAAC,OAAO,EAAE,CAAC,KAAK,CAAC,CAAC;YACxB,CAAC;SACF,CAAC,CAAC;QAEH,OAAO,MAAkC,CAAC;IAC5C,CAAC;CACF"}

package/dist/AgentChat.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Configuration for defining an agent chat
+ *
+ * This interface is used to define the structure of an agent chat.
+ *
+ * @interface AgentChatConfig
+ * @property {string} agentChatId - Unique identifier for the agent chat
+ */
+export interface AgentChatConfig {
+    agentChatId: string;
+}
+/**
+ * AgentChat class for interacting with the agent chat
+ *
+ * This class provides methods to interact with the agent chat.
+ *
+ * @class AgentChat
+ * @template ACC - AgentChat configuration type
+ */
+export declare class AgentChat<ACC extends AgentChatConfig = AgentChatConfig> {
+    private agentChatId;
+    private appId;
+    private token?;
+    /**
+     * Creates a new AgentChat instance
+     * @param {ACC} config - Configuration for the agent chat
+     */
+    constructor(config: ACC, { appId, token }: {
+        appId: string;
+        token?: string;
+    });
+    /**
+     * Get the props for the AgentChat component
+     * @returns {Object} - The props for the AgentChat component
+     */
+    getAgentChatComponentProps(): {
+        agentChatId: string;
+        appId: string;
+        token: string | undefined;
+    };
+}
+//# sourceMappingURL=AgentChat.d.ts.map

package/dist/AgentChat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChat.d.ts","sourceRoot":"","sources":["../src/AgentChat.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,qBAAa,SAAS,CAAC,GAAG,SAAS,eAAe,GAAG,eAAe;IAClE,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,KAAK,CAAS;IACtB,OAAO,CAAC,KAAK,CAAC,CAAS;IACvB;;;OAGG;gBACS,MAAM,EAAE,GAAG,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAM5E;;;OAGG;IACH,0BAA0B;;;;;CAO3B"}

package/dist/AgentChat.js

@@ -0,0 +1,34 @@
+/**
+ * AgentChat class for interacting with the agent chat
+ *
+ * This class provides methods to interact with the agent chat.
+ *
+ * @class AgentChat
+ * @template ACC - AgentChat configuration type
+ */
+export class AgentChat {
+    agentChatId;
+    appId;
+    token;
+    /**
+     * Creates a new AgentChat instance
+     * @param {ACC} config - Configuration for the agent chat
+     */
+    constructor(config, { appId, token }) {
+        this.agentChatId = config.agentChatId;
+        this.appId = appId;
+        this.token = token;
+    }
+    /**
+     * Get the props for the AgentChat component
+     * @returns {Object} - The props for the AgentChat component
+     */
+    getAgentChatComponentProps() {
+        return {
+            agentChatId: this.agentChatId,
+            appId: this.appId,
+            token: this.token,
+        };
+    }
+}
+//# sourceMappingURL=AgentChat.js.map

package/dist/AgentChat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentChat.js","sourceRoot":"","sources":["../src/AgentChat.ts"],"names":[],"mappings":"AAYA;;;;;;;GAOG;AACH,MAAM,OAAO,SAAS;IACZ,WAAW,CAAS;IACpB,KAAK,CAAS;IACd,KAAK,CAAU;IACvB;;;OAGG;IACH,YAAY,MAAW,EAAE,EAAE,KAAK,EAAE,KAAK,EAAqC;QAC1E,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC,WAAW,CAAC;QACtC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;IAED;;;OAGG;IACH,0BAA0B;QACxB,OAAO;YACL,WAAW,EAAE,IAAI,CAAC,WAAW;YAC7B,KAAK,EAAE,IAAI,CAAC,KAAK;YACjB,KAAK,EAAE,IAAI,CAAC,KAAK;SAClB,CAAC;IACJ,CAAC;CACF"}

package/dist/ClientSdk.d.ts

@@ -0,0 +1,309 @@
+import { Action, type ActionConfig } from "./Action.js";
+import { AgentChat, AgentChatConfig } from "./AgentChat.js";
+import { Entity, type EntityConfig } from "./Entity.js";
+import { Page, type PageConfig } from "./Page.js";
+/**
+ * Represents a user's data
+ * @interface User
+ * @property {string} [id] - The user's ID (optional, must exist if user is authenticated)
+ * @property {string} [email] - The user's email (optional, must exist if user is authenticated)
+ * @property {string} [name] - The user's name (optional, must exist if user is authenticated)
+ * @property {string} [profileImageUrl] - The user's profile image URL (optional)
+ * @property {string} [firstName] - The user's first name (optional)
+ * @property {string} [lastName] - The user's last name (optional)
+ * @property {string} [role] - The user's role name (optional)
+ * @property {string} [permission] - The user's permission level: 'build' (can modify app) or 'use' (read-only) (optional)
+ * @property {boolean} [isAuthenticated] - Whether the user is authenticated
+ */
+export interface User {
+    id?: string;
+    email?: string;
+    name?: string;
+    profileImageUrl?: string;
+    firstName?: string;
+    lastName?: string;
+    role?: string;
+    permission?: "build" | "use";
+    isAuthenticated: boolean;
+}
+export interface UpdateUserOptions {
+    clientOnly?: boolean;
+}
+/**
+ * Configuration options for initializing a ClientSdk instance
+ * @interface ClientConfig
+ * @property {string} appId - The unique identifier for the application
+ * @property {string} token - The token for the application
+ */
+export interface ClientConfig {
+    appId: string;
+    token?: string;
+}
+/**
+ * Main client SDK for interacting with entities, actions, and pages
+ *
+ * This SDK provides a unified interface for working with:
+ * - Entities: Data objects stored in tables (CRUD operations)
+ * - Actions: Executable workflows that perform operations (any server-side logic)
+ * - Pages: Application pages with URL and parameter handling
+ * - AgentChat: Interact with the agent chat
+ * - User: The user's data
+ *
+ * @class ClientSdk
+ */
+export declare class ClientSdk {
+    readonly appId: string;
+    private user;
+    readonly token?: string;
+    private readonly entities;
+    private readonly actions;
+    private readonly pages;
+    private readonly agentChats;
+    /**
+     * Creates a new ClientSdk instance
+     * @param {ClientConfig} config - Configuration options
+     * @example
+     * ```ts
+     * const client = new ClientSdk({ appId: 'my-application-id' });
+     * ```
+     */
+    constructor(config: ClientConfig);
+    authenticate(): Promise<void>;
+    /**
+     * Gets or creates an Entity instance for the specified entity configuration
+     *
+     * An Entity represents a data object stored in a table with CRUD operations.
+     * EntityConfig requires:
+     * - tableBlockId: Unique identifier for the table
+     * - instanceType: TypeScript type defining the entity's structure
+     *
+     * @template EC - Entity configuration type
+     * @param {EC} entityConfig - Configuration for the entity
+     * @returns {Entity<EC>} An Entity instance for the given configuration
+     * @example
+     * ```ts
+     * // Define a User entity configuration
+     * const userEntityConfig = {
+     *   tableBlockId: 'users-table-id',
+     *   instanceType: {} as {
+     *     name: string;
+     *     email: string;
+     *     role: 'admin' | 'user';
+     *   }
+     * };
+     *
+     * // Get the entity instance
+     * const userEntity = client.entity(userEntityConfig);
+     *
+     * // Use it for CRUD operations
+     * const users = await userEntity.findMany();
+     * ```
+     */
+    entity<EC extends EntityConfig = EntityConfig>(entityConfig: EC): Entity<EC>;
+    /**
+     * Gets or creates an Action instance for the specified action configuration
+     *
+     * An Action represents an executable workflow that performs server-side operations
+     * of any kind. Actions can handle data processing, business logic, integrations
+     * with external services, AI operations, and any other server-side functionality.
+     * Actions are particularly powerful for implementing AI capabilities.
+     *
+     * ActionConfig requires:
+     * - actionBlockId: Unique identifier for the action workflow
+     * - inputInstanceType: TypeScript type defining the action's input parameters
+     * - outputInstanceType: TypeScript type defining the action's output structure
+     *
+     * @template AC - Action configuration type
+     * @param {AC} actionConfig - Configuration for the action
+     * @returns {Action<AC>} An Action instance for the given configuration
+     * @example
+     * ```ts
+     * // Example 1: Data processing action
+     * const processOrderConfig = {
+     *   actionBlockId: 'process-order-id',
+     *   inputInstanceType: {} as {
+     *     orderId: string;
+     *     userId: string;
+     *     items: Array<{ productId: string; quantity: number }>;
+     *   },
+     *   outputInstanceType: {} as {
+     *     success: boolean;
+     *     orderNumber: string;
+     *     estimatedDelivery: string;
+     *   }
+     * };
+     *
+     * const processOrderAction = client.action(processOrderConfig);
+     * const result = await processOrderAction.execute({
+     *   orderId: 'order-123',
+     *   userId: 'user-456',
+     *   items: [{ productId: 'prod-789', quantity: 2 }]
+     * });
+     *
+     * // Example 2: Authentication action
+     * const loginUserConfig = {
+     *   actionBlockId: 'login-user-id',
+     *   inputInstanceType: {} as {
+     *     email: string;
+     *     password: string;
+     *   },
+     *   outputInstanceType: {} as {
+     *     success: boolean;
+     *     token?: string;
+     *     error?: string;
+     *   }
+     * };
+     *
+     * const loginAction = client.action(loginUserConfig);
+     * const loginResult = await loginAction.execute({
+     *   email: 'user@example.com',
+     *   password: 'password123'
+     * });
+     * ```
+     */
+    action<AC extends ActionConfig = ActionConfig>(actionConfig: AC): Action<AC>;
+    /**
+     * Gets or creates a Page instance for the specified page configuration
+     *
+     * A Page represents an application page with URL and parameter handling.
+     * PageConfig requires:
+     * - pageBlockId: Unique identifier for the page
+     * - pageName: Name of the page
+     *
+     * @template PC - Page configuration type
+     * @param {PC} pageConfig - Configuration for the page
+     * @returns {Page<PC>} A Page instance for the given configuration
+     * @example
+     * ```ts
+     * // Define a product page configuration
+     * const productPageConfig = {
+     *   pageBlockId: 'product-page-id'
+     *   pageName: 'product-page'
+     * };
+     *
+     * // Get the page instance
+     * const productPage = client.page(productPageConfig);
+     * ```
+     */
+    page<PC extends PageConfig = PageConfig>(pageConfig: PC): Page<PC>;
+    /**
+     * Gets or creates an AgentChat instance for the specified agent chat configuration
+     *
+     * An AgentChat represents an agent chat with the user.
+     * AgentChatConfig requires:
+     * - agentChatId: Unique identifier for the agent chat
+     *
+     * @template ACC - AgentChat configuration type
+     * @param {ACC} agentChatConfig - Configuration for the agent chat
+     * @returns {AgentChat<ACC>} An AgentChat instance for the given configuration
+     * @example
+     * ```ts
+     * // Define a agent chat configuration
+     * const agentChatConfig = {
+     *   agentChatId: 'agent-chat-id'
+     * };
+     *
+     * // Get the agent chat instance
+     * const agentChat = client.agentChat(agentChatConfig);
+     * ```
+     */
+    agentChat<ACC extends AgentChatConfig = AgentChatConfig>(agentChatConfig: ACC): AgentChat<ACC>;
+    private getUploadUrl;
+    upload(file: File, { onProgress }: {
+        onProgress: (percentage: number) => void;
+    }): Promise<string>;
+    /**
+     * Returns the current user information
+     *
+     * This method provides access to the user's data
+     * that was provided during SDK initialization.
+     *
+     * @returns {User} The current user object
+     * @example
+     * ```ts
+     * // Get the current user information
+     * const user = client.getUser();
+     * console.log(`Logged in as: ${user.username}`);
+     * ```
+     */
+    getUser(): User;
+    /**
+     * Changes a user's role
+     * @param userId - The user ID to change the role for
+     * @param role - The new role to set for the user
+     * @param options - Options for the change
+     * @returns {Promise<void>} A promise that resolves when the role change is complete
+     * @example
+     * ```ts
+     * await client.changeUserRole('123', 'admin');
+     * ```
+     */
+    changeUserRole(userId: string, role: string, options?: UpdateUserOptions): Promise<void>;
+    /**
+     * Sends a passwordless login link (magic link) to the user's email
+     *
+     * This method sends an email containing a one-time login link that allows users
+     * to authenticate without entering a password. When the user clicks the link in
+     * their email, they will be automatically logged into the application.
+     *
+     * @param {Object} params - Parameters for sending the login link
+     * @param {string} params.email - The email address to send the login link to
+     * @returns {Promise<void>} A promise that resolves when the login link is sent successfully
+     * @example
+     * ```ts
+     * // Send a login link to a user
+     * const result = await client.sendLoginLink({
+     *   email: 'user@example.com'
+     * });
+     *
+     * // Typically used in a login form
+     * async function handlePasswordlessLogin(email: string) {
+     *   try {
+     *     await client.sendLoginLink({ email });
+     *     alert('Check your email for a login link!');
+     *   } catch (error) {
+     *     console.error('Failed to send login link:', error);
+     *   }
+     * }
+     * ```
+     */
+    sendLoginLink({ email }: {
+        email: string;
+    }): Promise<void>;
+    /**
+     * Gets the Google OAuth login URL for authentication
+     *
+     * This method generates a URL that initiates the Google OAuth login flow.
+     * When users navigate to this URL, they will be redirected to Google's
+     * authentication page. After successful authentication with Google, they
+     * will be redirected back to the application and automatically logged in.
+     *
+     * @returns {string} The Google OAuth login URL
+     * @example
+     * ```ts
+     * // Get the Google login URL
+     * const googleUrl = client.getGoogleLoginUrl();
+     *
+     * // Redirect user to Google login
+     * window.location.href = googleUrl;
+     *
+     * // Use in a button with onClick
+     * function GoogleLoginButton() {
+     *   const handleGoogleLogin = () => {
+     *     const url = client.getGoogleLoginUrl();
+     *     window.location.href = url;
+     *   };
+     *
+     *   return <Button onClick={handleGoogleLogin}>Sign in with Google</Button>;
+     * }
+     *
+     * // Use in a Link component
+     * function GoogleLoginLink() {
+     *   const googleUrl = client.getGoogleLoginUrl();
+     *   return <Link to={googleUrl}>Sign in with Google</Link>;
+     * }
+     * ```
+     */
+    getGoogleLoginUrl(): string;
+}
+//# sourceMappingURL=ClientSdk.d.ts.map