@pillar-ai/sdk 0.1.21 → 0.1.22

package/dist/api/ag-ui-bridge.d.ts

@@ -0,0 +1,49 @@
+/**
+ * AG-UI Bridge
+ *
+ * Temporary bridge that converts Phase 1's JSON-RPC wrapped AG-UI events
+ * to native AG-UI events. This allows the SDK to use AG-UI patterns while
+ * the backend still uses JSON-RPC transport.
+ *
+ * Will be removed after Phase 3 (pure AG-UI transport).
+ */
+import type { AGUIEvent } from '@ag-ui/core';
+/**
+ * Unwrap an AG-UI event from a JSON-RPC notification.
+ *
+ * Phase 1 backend wraps AG-UI events like this:
+ * {
+ *   "jsonrpc": "2.0",
+ *   "method": "notifications/progress",
+ *   "params": {
+ *     "ag_ui_event": { "type": "RUN_STARTED", ... }
+ *   }
+ * }
+ *
+ * @param jsonRpcEvent - The JSON-RPC notification from the backend
+ * @returns The unwrapped AG-UI event, or null if not an AG-UI event
+ */
+export declare function unwrapAGUIEvent(jsonRpcEvent: unknown): AGUIEvent | null;
+/**
+ * Check if a JSON-RPC event contains an AG-UI event.
+ */
+export declare function isAGUIWrappedEvent(jsonRpcEvent: unknown): boolean;
+/**
+ * Convert legacy MCP progress events to AG-UI events.
+ *
+ * This is for backwards compatibility during the transition.
+ * Converts old-style progress events to AG-UI events.
+ *
+ * @param legacyEvent - The legacy MCP progress event
+ * @returns An array of AG-UI events (may be multiple for some conversions)
+ */
+export declare function convertLegacyProgressToAGUI(legacyEvent: Record<string, unknown>): AGUIEvent[];
+/**
+ * Process a raw SSE event and extract AG-UI events.
+ *
+ * Handles both new AG-UI wrapped events and legacy progress events.
+ *
+ * @param rawEvent - The parsed JSON from an SSE data line
+ * @returns An array of AG-UI events
+ */
+export declare function processSSEEvent(rawEvent: unknown): AGUIEvent[];

package/dist/api/ag-ui-client.d.ts

@@ -0,0 +1,102 @@
+/**
+ * AG-UI Protocol Client for Pillar SDK
+ *
+ * Implements the AG-UI specification for streaming agent interactions.
+ * Uses the @ag-ui/client HttpAgent for transport.
+ *
+ * Copyright (C) 2025 Pillar Team
+ */
+import type { ResolvedConfig } from '../core/config';
+export interface AGUIStreamCallbacks {
+    /** Called when run starts */
+    onRunStarted?: (runId: string) => void;
+    /** Called when run completes successfully */
+    onRunFinished?: () => void;
+    /** Called on error */
+    onError?: (error: Error) => void;
+    /** Called when a step starts */
+    onStepStarted?: (stepName: string) => void;
+    /** Called when a step finishes */
+    onStepFinished?: (stepName: string) => void;
+    /** Called for text message streaming */
+    onTextContent?: (messageId: string, delta: string) => void;
+    /** Called when text message completes */
+    onTextComplete?: (messageId: string, fullContent: string) => void;
+    /** Called when tool call starts (for UI display) */
+    onToolCallStart?: (toolCallId: string, toolName: string) => void;
+    /** Called with tool call arguments */
+    onToolCallArgs?: (toolCallId: string, argsJson: string) => void;
+    /** Called when tool call completes */
+    onToolCallEnd?: (toolCallId: string) => void;
+    /** Called when tool result is available */
+    onToolCallResult?: (toolCallId: string, result: string) => void;
+    /** Called for state delta events (sources, actions, plan) */
+    onStateDelta?: (delta: unknown[]) => void;
+    /** Called for state snapshots */
+    onStateSnapshot?: (state: unknown) => void;
+}
+export interface ClientTool {
+    name: string;
+    description: string;
+    parameters: Record<string, unknown>;
+    /** Handler function - called when agent requests this tool */
+    handler?: (args: Record<string, unknown>) => Promise<unknown>;
+}
+export declare class AGUIClient {
+    private config;
+    private agent;
+    private currentRunId;
+    private currentThreadId;
+    private messageAccumulators;
+    private toolArgAccumulators;
+    private toolCallNames;
+    private registeredTools;
+    constructor(config: ResolvedConfig);
+    /**
+     * Get or create a persistent thread ID for this session.
+     */
+    private getOrCreateThreadId;
+    private getBrowserLanguage;
+    /**
+     * Register a client-side tool that can be called by the agent.
+     */
+    registerTool(tool: ClientTool): void;
+    /**
+     * Unregister a client-side tool.
+     */
+    unregisterTool(toolName: string): void;
+    /**
+     * Send a message and stream the agent's response.
+     */
+    chat(message: string, callbacks: AGUIStreamCallbacks, options?: {
+        history?: Array<{
+            role: 'user' | 'assistant';
+            content: string;
+        }>;
+        userContext?: Array<{
+            type: string;
+            [key: string]: unknown;
+        }>;
+        signal?: AbortSignal;
+    }): Promise<void>;
+    /**
+     * Execute a client-side tool if registered.
+     */
+    private maybeExecuteClientTool;
+    /**
+     * Send tool execution result back to the server.
+     */
+    sendToolResult(toolCallId: string, result: unknown, error?: string): Promise<void>;
+    /**
+     * Start a new conversation thread.
+     */
+    newThread(): string;
+    /**
+     * Get current thread ID.
+     */
+    get threadId(): string;
+    /**
+     * Get current run ID.
+     */
+    get runId(): string | null;
+}

package/dist/api/ag-ui-handler.d.ts

@@ -0,0 +1,89 @@
+/**
+ * AG-UI Event Handler
+ *
+ * Processes AG-UI protocol events and maintains UI state.
+ * Replaces the complex JSON-RPC parsing in mcp-client.ts.
+ */
+import type { AGUIEvent } from '@ag-ui/core';
+/** A streaming text message being accumulated */
+export interface StreamingMessage {
+    id: string;
+    role: 'user' | 'assistant';
+    content: string;
+    complete: boolean;
+    /** Which step this message belongs to (for thinking vs response) */
+    stepName?: string;
+}
+/** A tool call being tracked */
+export interface ToolCallState {
+    id: string;
+    name: string;
+    args: string;
+    result?: unknown;
+    complete: boolean;
+    /** True if this tool executes on the client (query action) */
+    isClientSide?: boolean;
+}
+/** State delta data (sources, actions, plan, etc.) */
+export interface StateDeltaData {
+    type: string;
+    data: unknown;
+    timestamp: number;
+}
+/** Complete AG-UI state */
+export interface AGUIState {
+    /** Current run ID */
+    runId: string | null;
+    /** Thread ID (replaces conversation_id) */
+    threadId: string | null;
+    /** Current step name (e.g., "reasoning", "tool_execution") */
+    currentStep: string | null;
+    /** Streaming messages keyed by message ID */
+    messages: Map<string, StreamingMessage>;
+    /** Tool calls keyed by tool call ID */
+    toolCalls: Map<string, ToolCallState>;
+    /** State deltas received (sources, actions, plans) */
+    stateDeltas: StateDeltaData[];
+    /** Whether the run is complete */
+    isComplete: boolean;
+    /** Error if run failed */
+    error: Error | null;
+}
+export interface AGUIHandlerCallbacks {
+    /** Called whenever state changes */
+    onStateChange: (state: AGUIState) => void;
+    /** Called when an error occurs */
+    onError: (error: Error) => void;
+    /** Called when run completes successfully */
+    onComplete: () => void;
+    /** Called when a client-side tool needs execution */
+    onClientToolCall?: (toolCall: ToolCallState) => Promise<unknown>;
+}
+/**
+ * Create an AG-UI event handler.
+ *
+ * Returns an object with a handleEvent method that processes
+ * AG-UI events and updates internal state.
+ */
+export declare function createAGUIHandler(callbacks: AGUIHandlerCallbacks): {
+    handleEvent: (event: AGUIEvent) => Promise<void>;
+    reset: () => void;
+    getState: () => AGUIState;
+};
+/**
+ * Register a tool as client-side.
+ * Called when the SDK registers an action with returns: true.
+ */
+export declare function registerClientSideTool(toolName: string): void;
+/**
+ * Unregister a client-side tool.
+ */
+export declare function unregisterClientSideTool(toolName: string): void;
+/**
+ * Check if a tool executes on the client side.
+ */
+export declare function isClientSideTool(toolName: string): boolean;
+/**
+ * Get all registered client-side tools.
+ */
+export declare function getClientSideTools(): string[];

package/dist/api/mcp-client.d.ts

@@ -22,8 +22,12 @@ export interface ToolResult {
     isError?: boolean;
     structuredContent?: {
         sources?: ArticleSummary[];
-        actions?: ActionData[];
-        /** Registered actions for dynamic action tools (persisted across turns) */
+        tools?: ToolData[];
+        /** @deprecated Use tools instead */
+        actions?: ToolData[];
+        /** Registered tools for dynamic tool invocations (persisted across turns) */
+        registered_tools?: Record<string, unknown>[];
+        /** @deprecated Use registered_tools instead */
         registered_actions?: Record<string, unknown>[];
     };
     _meta?: {
@@ -31,32 +35,36 @@ export interface ToolResult {
         query_log_id?: string;
     };
 }
-/** Action data from MCP server */
-export interface ActionData {
+/** Tool data from MCP server */
+export interface ToolData {
     id: string;
     name: string;
     description: string;
     action_type: string;
-    /** If true, action executes immediately without user clicking */
+    /** If true, tool executes immediately without user clicking */
     auto_run: boolean;
-    /** If true, action completes without waiting for host confirmation */
+    /** If true, tool completes without waiting for host confirmation */
     auto_complete: boolean;
-    /** If true, action returns data for agent reasoning */
+    /** If true, tool returns data for agent reasoning */
     returns_data: boolean;
     score: number;
     data: Record<string, unknown>;
 }
-/** Action request from agent (unified for all action execution) */
-export interface ActionRequest {
-    /** Action name to execute */
+/** @deprecated Use ToolData instead */
+export type ActionData = ToolData;
+/** Tool request from agent (unified for all tool execution) */
+export interface ToolRequest {
+    /** Tool name to execute */
     action_name: string;
-    /** Parameters for the action */
+    /** Parameters for the tool */
     parameters: Record<string, unknown>;
-    /** Full action definition (optional, for handler lookup) */
-    action?: ActionData;
+    /** Full tool definition (optional, for handler lookup) */
+    action?: ToolData;
     /** Unique ID for this specific tool invocation (for result correlation) */
     tool_call_id?: string;
 }
+/** @deprecated Use ToolRequest instead */
+export type ActionRequest = ToolRequest;
 /** Token usage data from the agentic loop (sent after each LLM iteration) */
 export interface TokenUsage {
     /** Input tokens for this iteration */
@@ -84,9 +92,13 @@ export interface StreamCallbacks {
     onToken?: (token: string) => void;
     /** Called when sources are available */
     onSources?: (sources: ArticleSummary[]) => void;
-    /** Called when actions are available */
-    onActions?: (actions: ActionData[]) => void;
-    /** Called when registered actions are received (for dynamic action tools) */
+    /** Called when tools are available */
+    onTools?: (tools: ToolData[]) => void;
+    /** @deprecated Use onTools instead */
+    onActions?: (actions: ToolData[]) => void;
+    /** Called when registered tools are received (for dynamic tool invocations) */
+    onRegisteredTools?: (tools: Record<string, unknown>[]) => void;
+    /** @deprecated Use onRegisteredTools instead */
     onRegisteredActions?: (actions: Record<string, unknown>[]) => void;
     /** Called on error */
     onError?: (error: string) => void;
@@ -112,8 +124,10 @@ export interface StreamCallbacks {
     }) => void;
     /** Called immediately with the request ID (for cancellation support) */
     onRequestId?: (requestId: number) => void;
-    /** Called when agent requests action execution (unified handler) */
-    onActionRequest?: (request: ActionRequest) => Promise<void>;
+    /** Called when agent requests tool execution (unified handler) */
+    onToolRequest?: (request: ToolRequest) => Promise<void>;
+    /** @deprecated Use onToolRequest instead */
+    onActionRequest?: (request: ToolRequest) => Promise<void>;
     /** Called when token usage is updated (after each LLM iteration) */
     onTokenUsage?: (usage: TokenUsage) => void;
 }
@@ -199,7 +213,9 @@ export declare class MCPClient {
             role: 'user' | 'assistant';
             content: string;
         }>;
-        /** Registered actions from previous turns (for dynamic action tools) */
+        /** Registered tools from previous turns (for dynamic tool invocations) */
+        registeredTools?: Record<string, unknown>[];
+        /** @deprecated Use registeredTools instead */
         registeredActions?: Record<string, unknown>[];
         signal?: AbortSignal;
         /** Conversation ID - generated client-side, always provided */
@@ -217,16 +233,18 @@ export declare class MCPClient {
      */
     cancelStream(requestId: number | string): Promise<void>;
     /**
-     * Send action result back to the agent.
+     * Send tool result back to the agent.
      *
-     * Called after executing a query action (returns_data=true).
+     * Called after executing a query tool (returns_data=true).
      * The result is sent to the agent for further reasoning in the ReAct loop.
      *
-     * @param actionName - The name of the action that was executed
+     * @param toolName - The name of the tool that was executed
      * @param result - The result data to send back to the agent
      * @param toolCallId - Unique ID for this specific tool invocation (for result correlation)
      * @returns Promise that resolves when the result is delivered, or rejects on error
      */
+    sendToolResult(toolName: string, result: unknown, toolCallId?: string): Promise<void>;
+    /** @deprecated Use sendToolResult instead */
     sendActionResult(actionName: string, result: unknown, toolCallId?: string): Promise<void>;
     /**
      * Send a client-side log to the server for debugging.
@@ -266,10 +284,14 @@ export interface ConversationStatus {
     user_message?: string;
     partial_response?: string;
     display_trace?: DisplayStep[];
+    registered_tools?: Record<string, unknown>[];
+    /** @deprecated Use registered_tools instead */
     registered_actions?: Record<string, unknown>[];
 }
 /**
- * Convert ActionData from MCP response to TaskButtonData for UI rendering.
+ * Convert ToolData from MCP response to TaskButtonData for UI rendering.
  */
-export declare function actionToTaskButton(action: ActionData): TaskButtonData;
+export declare function toolToTaskButton(tool: ToolData): TaskButtonData;
+/** @deprecated Use toolToTaskButton instead */
+export declare const actionToTaskButton: typeof toolToTaskButton;
 export {};

package/dist/cli/sync.js

@@ -25,15 +25,16 @@ function parseArgs(args) {
 }
 function printUsage() {
   console.log(`
-Pillar Action Sync CLI
+Pillar Tool Sync CLI
 
-Scans for usePillarAction/defineAction calls and syncs to the Pillar backend.
+Scans for usePillarTool/defineTool calls and syncs to the Pillar backend.
+Also supports legacy usePillarAction/defineAction calls.
 
 Usage:
   npx pillar-sync --scan <dir> [--local]
 
 Arguments:
-  --scan <dir>       Directory to scan for usePillarAction/defineAction calls
+  --scan <dir>       Directory to scan for usePillarTool/defineTool calls
   --local            Use localhost:8003 as the API URL (for local development)
   --help             Show this help message
 
@@ -46,7 +47,7 @@ Environment Variables:
   GIT_SHA            Git commit SHA for traceability
 
 Examples:
-  # Scan and sync actions
+  # Scan and sync tools
   PILLAR_SLUG=my-app PILLAR_SECRET=xxx npx pillar-sync --scan ./src
 
   # Local development
@@ -207,7 +208,7 @@ function evaluateNode(node, ts) {
   }
   return void 0;
 }
-async function scanActions(scanDir) {
+async function scanTools(scanDir) {
   const absoluteDir = path.resolve(process.cwd(), scanDir);
   if (!fs.existsSync(absoluteDir)) {
     throw new Error(`Scan directory not found: ${absoluteDir}`);
@@ -216,19 +217,25 @@ async function scanActions(scanDir) {
   try {
     ts = await import("typescript");
   } catch {
-    console.error("[pillar-sync] TypeScript is required for --scan mode.");
-    console.error("[pillar-sync] Install it: npm install -D typescript");
-    process.exit(1);
+    try {
+      const { createRequire } = await import("module");
+      const require2 = createRequire(path.join(process.cwd(), "node_modules", "_placeholder.js"));
+      ts = require2("typescript");
+    } catch {
+      console.error("[pillar-sync] TypeScript is required for --scan mode.");
+      console.error("[pillar-sync] Install it: npm install -D typescript");
+      process.exit(1);
+    }
   }
   const files = globFiles(absoluteDir, [".ts", ".tsx", ".js", ".jsx", ".mjs"]);
   console.log(`[pillar-sync] Scanning ${files.length} files in ${scanDir}`);
-  const PATTERNS = ["defineAction", "usePillarAction"];
+  const PATTERNS = ["defineTool", "usePillarTool", "defineAction", "usePillarAction"];
   const candidateFiles = files.filter((file) => {
     const content = fs.readFileSync(file, "utf-8");
     return PATTERNS.some((p) => content.includes(p));
   });
-  console.log(`[pillar-sync] Found ${candidateFiles.length} files with action definitions`);
-  const actions = [];
+  console.log(`[pillar-sync] Found ${candidateFiles.length} files with tool definitions`);
+  const tools = [];
   for (const filePath of candidateFiles) {
     let visit2 = function(node) {
       if (ts.isCallExpression(node)) {
@@ -237,18 +244,22 @@ async function scanActions(scanDir) {
         if (ts.isIdentifier(callee)) {
           isTargetCall = PATTERNS.includes(callee.text);
         } else if (ts.isPropertyAccessExpression(callee)) {
-          isTargetCall = callee.name.text === "defineAction";
+          isTargetCall = callee.name.text === "defineTool" || callee.name.text === "defineAction";
         }
         if (isTargetCall && node.arguments.length > 0) {
           const arg = node.arguments[0];
           const lineNumber = sourceFile.getLineAndCharacterOfPosition(node.getStart()).line + 1;
           const relativePath = path.relative(process.cwd(), filePath);
-          const processActionObject = (obj, line) => {
+          const processToolObject = (obj, line) => {
             if (obj && typeof obj.name === "string" && typeof obj.description === "string") {
-              actions.push({
+              let toolType = obj.type;
+              if (toolType === "trigger_action") {
+                toolType = "trigger_tool";
+              }
+              tools.push({
                 name: obj.name,
                 description: obj.description,
-                type: obj.type,
+                type: toolType,
                 inputSchema: obj.inputSchema,
                 examples: obj.examples,
                 autoRun: obj.autoRun,
@@ -259,29 +270,29 @@ async function scanActions(scanDir) {
               console.log(`[pillar-sync]   ${obj.name} (${relativePath}:${line})`);
             } else if (obj) {
               console.warn(
-                `[pillar-sync] \u26A0 Skipping action at ${relativePath}:${line} \u2014 missing name or description`
+                `[pillar-sync] \u26A0 Skipping tool at ${relativePath}:${line} \u2014 missing name or description`
               );
             }
           };
           if (ts.isObjectLiteralExpression(arg)) {
             const obj = evaluateNode(arg, ts);
-            processActionObject(obj, lineNumber);
+            processToolObject(obj, lineNumber);
           } else if (ts.isArrayLiteralExpression(arg)) {
             for (const element of arg.elements) {
               if (ts.isObjectLiteralExpression(element)) {
                 const elementLine = sourceFile.getLineAndCharacterOfPosition(element.getStart()).line + 1;
                 const obj = evaluateNode(element, ts);
-                processActionObject(obj, elementLine);
+                processToolObject(obj, elementLine);
               } else {
                 const elementLine = sourceFile.getLineAndCharacterOfPosition(element.getStart()).line + 1;
                 console.warn(
-                  `[pillar-sync] \u26A0 Skipping action at ${relativePath}:${elementLine} \u2014 array element is not an inline object literal`
+                  `[pillar-sync] \u26A0 Skipping tool at ${relativePath}:${elementLine} \u2014 array element is not an inline object literal`
                 );
               }
             }
           } else {
             console.warn(
-              `[pillar-sync] \u26A0 Skipping action at ${relativePath}:${lineNumber} \u2014 argument is not an inline object literal or array (variable reference can't be resolved statically)`
+              `[pillar-sync] \u26A0 Skipping tool at ${relativePath}:${lineNumber} \u2014 argument is not an inline object literal or array (variable reference can't be resolved statically)`
             );
           }
         }
@@ -300,25 +311,32 @@ async function scanActions(scanDir) {
     );
     visit2(sourceFile);
   }
-  return actions;
+  return tools;
+}
+function normalizeTypeForBackend(type) {
+  if (type === "trigger_tool") {
+    return "trigger_action";
+  }
+  return type || "trigger_action";
 }
-function buildManifestFromScan(actions, platform, version, gitSha) {
+function buildManifestFromScan(tools, platform, version, gitSha) {
   const entries = [];
-  for (const action of actions) {
+  for (const tool of tools) {
     const entry = {
-      name: action.name,
-      description: action.description,
-      type: action.type || "trigger_action"
+      name: tool.name,
+      description: tool.description,
+      // Normalize trigger_tool → trigger_action for backend API compatibility
+      type: normalizeTypeForBackend(tool.type)
     };
-    if (action.examples?.length)
-      entry.examples = action.examples;
-    if (action.autoRun)
-      entry.auto_run = action.autoRun;
-    if (action.autoComplete !== void 0)
-      entry.auto_complete = action.autoComplete;
+    if (tool.examples?.length)
+      entry.examples = tool.examples;
+    if (tool.autoRun)
+      entry.auto_run = tool.autoRun;
+    if (tool.autoComplete !== void 0)
+      entry.auto_complete = tool.autoComplete;
     entry.returns_data = true;
-    if (action.inputSchema)
-      entry.data_schema = action.inputSchema;
+    if (tool.inputSchema)
+      entry.data_schema = tool.inputSchema;
     entries.push(entry);
   }
   return {
@@ -327,6 +345,7 @@ function buildManifestFromScan(actions, platform, version, gitSha) {
     gitSha,
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     actions: entries
+    // Keep 'actions' key for backend API compatibility
   };
 }
 async function main() {
@@ -362,21 +381,21 @@ async function main() {
   const platform = process.env.PILLAR_PLATFORM || "web";
   const version = process.env.PILLAR_VERSION || getPackageVersion();
   const gitSha = process.env.GIT_SHA || getGitSha();
-  console.log(`[pillar-sync] Scanning for actions in: ${scanDir}`);
-  let scannedActions;
+  console.log(`[pillar-sync] Scanning for tools in: ${scanDir}`);
+  let scannedTools;
   try {
-    scannedActions = await scanActions(scanDir);
+    scannedTools = await scanTools(scanDir);
   } catch (error) {
-    console.error(`[pillar-sync] Failed to scan actions:`, error);
+    console.error(`[pillar-sync] Failed to scan tools:`, error);
     process.exit(1);
   }
-  const actionCount = scannedActions.length;
-  console.log(`[pillar-sync] Found ${actionCount} actions`);
-  if (actionCount === 0) {
-    console.warn("[pillar-sync] No actions found. Nothing to sync.");
+  const toolCount = scannedTools.length;
+  console.log(`[pillar-sync] Found ${toolCount} tools`);
+  if (toolCount === 0) {
+    console.warn("[pillar-sync] No tools found. Nothing to sync.");
     process.exit(0);
   }
-  const manifest = buildManifestFromScan(scannedActions, platform, version, gitSha);
+  const manifest = buildManifestFromScan(scannedTools, platform, version, gitSha);
   console.log(`[pillar-sync] Platform: ${platform}`);
   console.log(`[pillar-sync] Version: ${version}`);
   console.log(`[pillar-sync] Git SHA: ${gitSha || "not available"}`);

package/dist/components/Button/FloatingButton.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Floating Help Button Component
+ * A floating action button that opens the help panel
+ */
+import type { ResolvedConfig, FloatingButtonPosition } from '../../core/config';
+/**
+ * FloatingButton class that manages the button lifecycle
+ * Uses Preact for rendering but maintains imperative control
+ */
+export declare class FloatingButton {
+    private config;
+    private onClick;
+    private container;
+    private stylesInjected;
+    private _isHidden;
+    constructor(config: ResolvedConfig, onClick: () => void);
+    /**
+     * Initialize the floating button
+     */
+    init(): void;
+    /**
+     * Set the open state (to update icon when panel opens)
+     */
+    setOpen(_isOpen: boolean): void;
+    /**
+     * Show the button
+     */
+    show(): void;
+    /**
+     * Hide the button
+     */
+    hide(): void;
+    /**
+     * Update button position
+     */
+    setPosition(position: FloatingButtonPosition): void;
+    /**
+     * Update button label
+     */
+    setLabel(label: string): void;
+    /**
+     * Destroy the button
+     */
+    destroy(): void;
+    private render;
+}