@intelliweave/embedded 1.6.45

package/dist/react/react.d.ts

@@ -0,0 +1,664 @@
+import React from 'react';
+
+/** ChatGPT config options */
+interface ChatGPTConfig {
+    /** API key */
+    apiKey: string;
+    /** Provider ID */
+    providerID?: string;
+    /** Endpoint URL if using a custom URL */
+    endpoint: string;
+    /** LLM model to use */
+    model: string;
+    /** System message to describe to the AI how to behave. */
+    systemMessage: string;
+    /** User ID used to uniquely identify users in ChatGPT's API */
+    userID: string;
+    /** If true, streams the text responses from the API */
+    stream: boolean;
+    /** Amount of estimated tokens to keep when trimming */
+    maxTokens: number;
+    /** Callback before the AI sends info to the LLM */
+    onBeforeMessageProcessing?: () => void;
+    /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
+    onAIMessage?: (text: string, isChunk: boolean) => void;
+    /** Callback when the AI starts performing an action */
+    onAIToolStart?: (toolName: string, input: any) => void;
+}
+/** ChatGPT tool config */
+interface ChatGPTToolConfig {
+    /** Name of the tool */
+    name: string;
+    /** Description of the tool */
+    description: string;
+    /** Parameters for the tool */
+    params: {
+        name: string;
+        type: string;
+        description: string;
+    }[];
+    /** Callback function to process the tool */
+    callback: (params: any) => any;
+    /** If true, this tool call will be removed from the message history after it is executed. */
+    removeFromMessageHistory?: boolean;
+    /** Misc app context */
+    [key: string]: any;
+}
+/**
+ * API for interacting with ChatGPT APIs.
+ */
+declare class ChatGPT {
+    /** ID */
+    id: string;
+    /** Metadata */
+    metadata: any;
+    /** Config */
+    config: ChatGPTConfig;
+    /** List of messages in the chat history */
+    messages: any[];
+    /** List of available tools */
+    tools: ChatGPTToolConfig[];
+    /** The maximum tool calls in sequence the AI can make before an error is thrown. */
+    maxToolCallsPerMessage: number;
+    private _hasRemovedToolCallHistorySinceLastMessage;
+    /** Statistics */
+    stats: {
+        /** Total tokens used this session */
+        tokensUsed: number;
+    };
+    /** Constructor */
+    constructor(config: ChatGPTConfig);
+    /** Send a message, and get the response */
+    sendMessage(message: string): Promise<string>;
+    /** @private Process messages in the chat history */
+    processMessages(): Promise<void>;
+    /** Trim message list */
+    trimMessages(): Promise<void>;
+    /** @private Send message list to the API and store the response */
+    sendToAPI(generatePayloadOnly?: boolean): Promise<any>;
+    /** Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
+    processIncomingMessage(message: string): void;
+    /** Register a tool. */
+    registerTool(tool: ChatGPTToolConfig): void;
+    /** @private Process a tool call request from the AI */
+    processToolCall(toolCall: any): Promise<void>;
+    /** Reset the conversation */
+    resetConversation(): void;
+}
+
+/**
+ * Speech output
+ *
+ * - event `speechstart` - When the speech starts
+ * - event `speechend` - When the speech ends
+ */
+declare class WebWeaverSpeechOutput extends EventTarget {
+    /** Reference to the AI */
+    private ai?;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /** Called when the AI speaks */
+    onTextOutputFromAI(e: CustomEvent): void;
+    /** Current player vars */
+    private currentPlayerVolume?;
+    private currentPlayer?;
+    /** Speak the text */
+    speak(text: string): Promise<void>;
+    private _speakWithLock;
+    /** True if currently playing audio */
+    get isSpeaking(): boolean;
+    /** Interrupt the previously playing audio */
+    interrupt(): Promise<void>;
+    /** Called when the speech output ends */
+    onSpeechEnd(): void;
+}
+
+/**
+ * An AudioWorklet module that records data from input and sends it to the host.
+ *
+ * - event `data` - Fired when data is available to be read.
+ */
+declare class PCMReceiverNode extends AudioWorkletNode {
+    /** @type {'int16' | 'float32'} The output data format */
+    format: string;
+    /**
+     * Creates a new PCMRecorderNode ready to receive PCM data.
+     *
+     * @param context - The audio context to use.
+     * @param sampleRate - The sample rate of the output data stream.
+     * @param format - The format of the output data stream.
+     * @param bufferSize - The size of the output buffer in elements (Int16Array or Float32Array items, depending on `format`).
+     */
+    constructor(context: AudioContext, sampleRate: number, format: 'int16' | 'int64' | 'float32', bufferSize: number);
+    /** @private Called when a message is received from the worklet */
+    onWorkletMessage(e: MessageEvent): void;
+    /** Called when data is received */
+    onData(buffer: Float32Array | Int16Array | BigInt64Array): void;
+}
+
+/**
+ * An AudioNode which sends events for when speech is detected
+ *
+ * - event `speechstart` - Fired when speech is detected
+ * - event `speechend` - Fired when speech ends
+ */
+declare class VoiceDetectionNode extends PCMReceiverNode {
+    /** True if voice is currently being detected */
+    isVoiceActive: boolean;
+    /** True if voice is active but may be ending soon */
+    get isVoicePossiblyEnding(): boolean;
+    /** Last date that voice was detected */
+    lastVoiceActiveDate: number;
+    /** Amount of time to wait after voice detection to detect that it has ended */
+    voiceEndTimeout: number;
+    /** Detection sensitivity, if the detection model outputs a number bigger than this it will be considered voice */
+    sensitivity: number;
+    /** Sensitivity threshold to end speaking */
+    sentivityEnd: number;
+    /** VAD model */
+    static vadModelURL: string;
+    /** Loaded VAD model */
+    private vad?;
+    /** Sample rate */
+    get sampleRate(): 8000 | 16000;
+    /** Number of samples */
+    get numberOfSamples(): number;
+    /** Number of sample chunks */
+    get numberOfSampleChunks(): number;
+    /** Output buffer size */
+    get outputBufferSize(): number;
+    /** True if the VAD model has been loaded */
+    get isModelLoaded(): boolean;
+    /** The time when to next reset the VAD model */
+    nextVadReset: number;
+    /** The current probability of active voice */
+    currentProbability: number;
+    /** Constructor */
+    constructor(audioContext: AudioContext);
+    /** Start loading */
+    loadModel(): Promise<void>;
+    private _lastVoiceActive;
+    /** Called when data is received */
+    onData(buffer: Float32Array): Promise<void>;
+    /** Called when speech is detected */
+    onSpeechStart(): void;
+    /** Called when speech ends */
+    onSpeechEnd(): void;
+}
+
+/**
+ * An AudioNode which isolates speech and outputs the audio data. Since we are reusing the VAD model node,
+ * output data is in 8000Hz Float32 format.
+ *
+ * - event `voicedata` - Fired when a chunk of voice is detected. `data` contains the recorded chunk of voice in a Float32Array.
+ * - event `voicedataend` - Fired when this chunk of voice ends. `data` contains an array of Float32Array containing the entirety of the recorded voice.
+ */
+declare class VoiceChunkOutputNode extends VoiceDetectionNode {
+    /** Stored buffers */
+    buffers: Float32Array[];
+    /** Recorded audio chunks with voice in it */
+    recordedBuffers: Float32Array[];
+    /** Last active state */
+    _voiceRecording: boolean;
+    /** Amount of audio data in the buffer, in seconds */
+    get bufferDuration(): number;
+    /** Amount of data to keep from before the user started speaking */
+    backBufferDurationSeconds: number;
+    /** Called when data is received */
+    onData(buffer: Float32Array): Promise<void>;
+    /** Called when a chunk of voice is recorded */
+    onVoiceChunk(buffer: Float32Array): void;
+    /** Called when the voice recording ends */
+    onVoiceEnd(buffers: Float32Array[]): void;
+}
+
+/**
+ * This AudioNode uses OpenAI's Whisper model to transcribe spoken speech to text.
+ *
+ * - event `transcription` - Fired when a transcription is ready. `text` contains the transcribed text.
+ */
+declare class OpenAITranscriptionNode extends VoiceChunkOutputNode {
+    /** OpenAI API key */
+    apiKey: string;
+    /** Pending buffers */
+    private pendingBuffers;
+    /** Last request */
+    private lastRequestAbortController?;
+    /** True if currently transcribing */
+    isTranscribing: boolean;
+    /** Constructor */
+    constructor(audioContext: AudioContext, apiKey: string);
+    /** Called when the voice recording ends */
+    onVoiceEnd(buffers: Float32Array[]): Promise<void>;
+    /** Called when a transcription is ready */
+    onVoiceTranscription(text: string): void;
+}
+
+/**
+ * This AudioNode uses IntelliWeave's servers to transcribe spoken speech to text.
+ *
+ * - event `transcription` - Fired when a transcription is ready. `text` contains the transcribed text.
+ */
+declare class IntelliWeaveTranscriptionNode extends VoiceChunkOutputNode {
+    /** Debug: Export each recording as a wav file for download */
+    static debugExportWav: boolean;
+    /** Server address for transcription */
+    apiAddress: string;
+    /** OpenAI API key */
+    apiKey: string;
+    /** WebSocket connection */
+    private ws?;
+    /** True if currently transcribing */
+    isTranscribing: boolean;
+    /** WebSocket shutdown timer */
+    private shutdownTimer?;
+    /** Constructor */
+    constructor(audioContext: AudioContext, apiKey: string);
+    /** Called when a voice chunk is received */
+    onVoiceChunk(buffer: Float32Array): Promise<void>;
+    /** Called when the voice recording ends */
+    onVoiceEnd(buffers: Float32Array[]): Promise<void>;
+    /** Called when a transcription is ready */
+    onVoiceTranscription(text: string): void;
+    /** Called when the WebSocket is closed */
+    onSocketClose(): void;
+}
+
+/**
+ * Handles speech recognition from the microphone
+ *
+ * - event `speechstart` - We have detected the user started speaking
+ * - event `speechend` - We have detected the user stopped speaking
+ * - event `speech` - Speech recognition result
+ * - event `start` - Speech recognition started
+ * - event `end` - Speech recognition ended
+ */
+declare class WebWeaverSpeechRecognition extends EventTarget {
+    /** Reference to the AI */
+    ai?: IntelliWeave;
+    /** True if recognition is running */
+    isRunning: boolean;
+    /** The audio analyser node */
+    analyserNode?: AnalyserNode;
+    /** The audio analyser buffer */
+    analyserBuffer?: Float32Array;
+    /** The microphone stream */
+    micStream?: MediaStream;
+    /** Returns true if speech recognition is supported by this persona and browser */
+    get isSupported(): boolean;
+    /** Currently active voice detection node */
+    voiceDetection?: IntelliWeaveTranscriptionNode | OpenAITranscriptionNode;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    private _skipEvents;
+    /** Start recognition */
+    start(): Promise<void>;
+    /** Stop recognition */
+    stop(): void;
+    /** @private Maximum volume heard this session */
+    maxVolumeHeard: number;
+    /** Get current (realtime) microphone volume level, from 0 to 1 */
+    get volumeLevel(): number;
+    /** True if currently detecting words being spoken */
+    get wordsCurrentlyBeingSpoken(): boolean;
+    /** True if currently transcribing voice to text */
+    get isTranscribing(): boolean;
+    /** Called when speech has been recorded */
+    onTranscription(e: CustomEvent): void;
+    /** Called to reset the speech recognizer */
+    reset(): Promise<void>;
+}
+
+/** Handles creating and managing the AudioContext */
+declare class AudioSystem {
+    /** Reference to the AI */
+    private ai?;
+    /** The speech recognition module. */
+    speechRecognition: WebWeaverSpeechRecognition;
+    /** The speech output module. */
+    speechOutput: WebWeaverSpeechOutput;
+    /** The audio context */
+    context?: AudioContext;
+    /** List of active named locks */
+    locks: string[];
+    /** Returns true if speech recognition and output is supported by this persona and browser */
+    static get isSupported(): boolean;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /** Create a named lock to enable the audio system */
+    beginAccess(namedLock: string): Promise<void>;
+    /** Stop accessing the audio system */
+    endAccess(namedLock: string): void;
+}
+
+/**
+ * This class allows you to use the AI as a logic engine, data extractor, etc.
+ */
+declare class AILogic {
+    /** Reference to the AI */
+    private ai?;
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /** Ask the AI a yes/no question associated with the specified data. Data must be JSON-serializable, or a string of any kind of data. */
+    boolean(question: string, data: any): Promise<boolean>;
+    /**
+        Ask the AI to select a choice from a list of options. The AI will return the selected choice.
+        @param question The question to ask the AI.
+        @param data The data to provide to the AI. This can be a string or a JSON-serializable object.
+        @param options The list of options to choose from.
+     */
+    choose(question: string, data: any, options: string[]): Promise<string | undefined>;
+    /**
+     * Ask the AI to extract data from a text. The AI will return the extracted data. Possibly an array of multiple extractions.
+     *   Example: extract(myData, true, [
+     *   { name: "id", type: "string", description: "The user's ID number." },
+     *   { name: "firstName", type: "string", description: "The user's first name" },
+     *   ])
+     * @param question The question to ask the AI.
+     * @param data The data to provide to the AI. This can be a string or a JSON-serializable object.
+     * @param allowMultiple Whether to allow multiple extractions or not.
+     * @param extractions The list of extractions to perform. Each extraction is an object with the following properties:
+     * - name: The name of the extraction. This will be the key in the returned object.
+     * - type: The type of the extraction. This can be "string", "number", "boolean", "date", "email", "url", "phone", "address", "name", "organization", "person", "location", "time", "duration", "money", "percentage", "quantity", "custom".
+     * - description: A description of the extraction. This is optional.
+     */
+    extract(question: string, data: any, allowMultiple: boolean, extractions: {
+        name: string;
+        type: string;
+        description?: string;
+    }[]): Promise<any>;
+    /**
+     * Generate a Markdown document based on the input query from the user.
+     *
+     * @param query The query to generate the document from.
+     * @param callback The callback that will be called when streaming the response. Each call will contain the full text that has been generated so far.
+     */
+    generateMarkdown(query: string, callback: (txt: string) => void): Promise<string | null>;
+    /**
+     * Perform an instruction.
+     *
+     * @param instruction Describe the action to perform.
+     * @param query The user query to pass to the AI.
+     * @param callback The callback that will be called when streaming the response. Each call will contain the full text that has been generated so far.
+     * @returns The final response from the AI.
+     */
+    instruct(instruction: string, query: string, callback: (txt: string) => void): Promise<string | null>;
+}
+
+/** Persona config received from the hub */
+interface WebWeaverGPTConfig {
+    /** ID */
+    id: string;
+    /** ChatGPT config */
+    model: ChatGPTConfig;
+    /** If true, message history will be sent to the IntelliWeave hub for analysis */
+    analytics?: boolean;
+    /** Persona name */
+    name?: string;
+    /** Instructions to the AI */
+    instructions?: string;
+    /** Introduction message, used in the automatic UI */
+    introductionMessage?: string;
+    /** Voice information */
+    voice?: {
+        /** Provider ID */
+        providerID: string;
+        /** API key for the provider */
+        apiKey: string;
+        /** Voice ID within the provider */
+        voiceID: string;
+    };
+    /** Transcription API information */
+    transcription?: {
+        /** Provider ID */
+        providerID: string;
+        /** API key for the provider */
+        apiKey: string;
+        /** Optional URL for the transcription service */
+        url?: string;
+    };
+    /** Knowledge base sources */
+    knowledge?: KnowledgeBaseSource[];
+}
+/**
+ * IntelliWeave interface, loads a Persona from the hub and allows you to interact with it. This is the main entry point into the IntelliWeave
+ * SDK when not using the built-in UI.
+ *
+ * - event `load` - Fired when the AI is loaded with a new configuration.
+ * - event `error` - Fired when an error occurs during loading.
+ * - event `webweaver_loaded` - Fired when the AI is loaded with a new configuration. This is a global event that is fired on the window object.
+ * - event `webweaver_error` - Fired when an error occurs during loading. This is a global event that is fired on the window object.
+ * - event `input` - Fired when the user sends a message to the AI.
+ * - event `output` - Fired when the AI sends a message back to the user. If `event.detail.isChunk` is true, the message is incomplete and will be followed by more chunks.
+ * - event `toolstart` - Fired when the AI starts performing an action.
+ * - event `tool` - Fired when the AI finishes performing an action.
+ */
+declare class IntelliWeave extends EventTarget {
+    /** App version */
+    static version: string;
+    /** Callback when a message from the AI is returned. If isChunk is true, it may be incomplete and be called again with more updates. */
+    onAIMessage?: (text: string, isChunk: boolean) => void;
+    /** Callback when the AI starts performing an action */
+    onAIToolStart?: ChatGPTConfig['onAIToolStart'];
+    /** Current conversation ID */
+    conversationID: string;
+    /** Knowledge database interface */
+    knowledgeBase: KnowledgeBase;
+    /** Current knowledge base items */
+    private _lastKBentries;
+    /** Config loaded from the API */
+    config?: WebWeaverGPTConfig;
+    /** Available LLMs */
+    models: {
+        id: string;
+        config: ChatGPTConfig;
+        priority?: number;
+    }[];
+    /** Current LLM */
+    currentModel?: ChatGPT;
+    /** The audio system. Set this to a new instance of AudioSystem to enable audio support */
+    audio: AudioSystem | null;
+    /** Silero VAD model blob */
+    vadModel?: Blob;
+    /** True if the AI has loaded */
+    get loaded(): boolean;
+    /** If loading fails, this stores the last error during load() */
+    error?: Error;
+    /** IntelliWeave API key */
+    apiKey: string;
+    /** Tracker for the current voice interaction */
+    _voiceTracker?: (text: string) => void;
+    /** Logic engine */
+    logic: AILogic;
+    /** A unique ID to identify this user. Defaults to a value stored in localStorage, or random. */
+    userID: string;
+    /** Extra data that will be passed to external knowledge base actions. */
+    extra: any;
+    /** Set model and load data from an API key */
+    load(apiKey: string): Promise<WebWeaverGPTConfig>;
+    /** Set the current model */
+    setModel(id: string): void;
+    private _lastSystemMsg;
+    /** Get the system message prefix, before the KB entries are added */
+    getContextPrefix(): Promise<any>;
+    /** Get system message to send to the AI */
+    onBeforeMessageProcessing(): Promise<void>;
+    /** Called to update the current knowledge base items */
+    updateKnowledgeBase(items: KnowledgeBaseItem[]): void;
+    private _lastOutput?;
+    /** @private Process incoming message from the AI. Can be used to respond to encoded actions in the text response. */
+    processIncomingMessage(message: string, isChunk?: boolean): void;
+    /** True if currently processing a message */
+    isProcessing: boolean;
+    /** Send a message, and get the response */
+    sendMessage(message: string): Promise<string | null>;
+    /** @private Called when the AI wants to run a KB action */
+    toolRunKBAction(kb: KnowledgeBaseItem, input: any): Promise<any>;
+    /** Submit an analytics event asynchronously */
+    submitAnalyticsEvent(data: any): void;
+    /** Reset the conversation */
+    resetConversation(): void;
+    /** Insert a message as if the assistant has written it */
+    insertAssistantMessage(message: string): void;
+    /** Export conversation state to a JSON object */
+    exportState(): {
+        type: string;
+        conversationID: string;
+        messages: any[] | undefined;
+    };
+    /** Import conversation state from JSON */
+    importState(state: any): void;
+    /** Clone this instance */
+    clone(): IntelliWeave;
+}
+
+/**
+ * Register knowledge base sources and perform searches.
+ */
+declare class KnowledgeBase {
+    /** Reference to the AI */
+    ai?: IntelliWeave;
+    /** Knowledge base sources */
+    _sources: KnowledgeBaseSource[];
+    /** List of sources returned from the last window event */
+    _windowSources: KnowledgeBaseSource[];
+    /** List of last search results */
+    lastResults: KnowledgeBaseItem[];
+    /** Individual knowledge base entries added manually by the application */
+    manualEntries: KnowledgeBaseItem[];
+    /** Constructor */
+    constructor(ai: IntelliWeave);
+    /**
+     * Register a new knowledge base source. You can pass either just a query function, or an ID and a query function.
+     *
+     * @param idOrQuery The ID of the source or a function that performs the query if no ID is provided
+     * @param query The function that performs the query. Can be undefined if the first param is a function.
+     */
+    registerSource(idOrQuery: string | KnowledgeBaseSource['query'], query?: KnowledgeBaseSource['query']): string;
+    /** Remove a knowledge base source */
+    removeSource(idOrQuery: string | KnowledgeBaseSource['query']): void;
+    /** Add a knowledge base item. */
+    addEntry(item: KnowledgeBaseItem): void;
+    /** Remove a knowledge base item. */
+    removeEntry(id: string): void;
+    /** Get all knowledge base sources */
+    get sources(): KnowledgeBaseSource[];
+    /** Search the knowledge base */
+    search(query: string): Promise<KnowledgeBaseItem[]>;
+    /** Get the KB entry with the specified ID. Requires the item to have been fetched in the last knowledge base query. */
+    getCachedEntry(id: string): KnowledgeBaseItem | undefined;
+    /** Create and register an external knowledge base source from a URL */
+    registerSourceFromURL(url: string, id?: string): void;
+    /** Clone this instance */
+    clone(): KnowledgeBase;
+}
+/** Knowledge base source */
+interface KnowledgeBaseSource {
+    /** Source ID */
+    id?: string;
+    /** Source name */
+    name?: string;
+    /** Optional description */
+    description?: string;
+    /** Optional icon URL */
+    icon?: string;
+    /** If true, this source will not be queried. */
+    disabled?: boolean;
+    /** Source query function. This function should return a list of knowledge base entries that optionally match the query. */
+    query?: (query: string) => (KnowledgeBaseItem[] | Promise<KnowledgeBaseItem[]>);
+    /** URL query for remote sources */
+    url?: string;
+}
+/** Knowledge base item */
+interface KnowledgeBaseItem {
+    /** Item ID */
+    id?: string;
+    /** Item type. */
+    type: 'info' | 'action' | 'tour' | 'input-event' | 'output-event';
+    /** Item name */
+    name: string;
+    /** Item tags. Helps with search optimization. */
+    tags?: string;
+    /** Item content. Can be a function to return a dynamic string. */
+    content: string | (() => string);
+    /** If true, this item will always be returned from all search results. */
+    isContext?: boolean;
+    /** If true, this item will not be visible to the AI. */
+    disabled?: boolean;
+    /** List of parameters for an action function. */
+    parameters?: ({
+        name: string;
+        type: 'string' | 'boolean' | 'number';
+        description: string;
+    })[];
+    /**
+     * Item action. The parameters are defined in `parameters`. The response is stringified and sent to the AI.
+     * You can return any JSON-serializable object. You can also return a string describing to the AI the action
+     * that was performed. If an error is thrown, the AI will respond appropriately to the user.
+     */
+    action?: (input: any, ai: IntelliWeave) => (any | Promise<any>);
+    /** If true, this item will be removed from the AI's message history after it gets called. This is a special case for LLMs that struggle with follow-up function calls and need to use the KB search functino first. */
+    removeFromMessageHistory?: boolean;
+}
+
+/**
+ * This is used when someone does `import "web-weaver-embedded"` and gives them a React Component (WebWeaverUI)
+ * that they can use in their React code.
+ */
+
+/** IntelliWeave embedded React component. This adds the Web Weaver floating button to the app. */
+declare const WebWeaverUI: (props: {
+    /** API key generated on the IntelliWeave hub */
+    apiKey: string;
+    /** If true, conversations will be recorded on the Hub for analysis. If not specified, uses the value specified on the Hub. */
+    analytics?: boolean;
+    /** The URL of the logo to use */
+    logo?: string;
+    /** If true, shows debug information in the console */
+    debug?: boolean;
+    /** Customize the context passed to the AI. Not needed since it's pulled from the Persona on the hub. */
+    context?: string;
+    /** The introduction message to show when the user first opens the chat. Not needed since it's pulled from the Persona on the hub. */
+    introductionMessage?: string;
+    /** Suggestion buttons to show on the first introduction message */
+    introductionSuggestions?: string[];
+    /** The knowledge base to add to the AI. */
+    knowledgeBase?: KnowledgeBaseItem[];
+    /** A list of custom sources */
+    sources?: KnowledgeBaseSource[];
+    /** X offset for the button from the right side of the screen, in pixels */
+    offsetX?: number;
+    /** Y offset for the button from the bottom of the screen, in pixels */
+    offsetY?: number;
+    /** User ID */
+    userID?: string;
+}) => React.JSX.Element | null;
+/** Global typescript definitions */
+declare global {
+    /** Web Component ... React supports any registered Web Component with dashes in the name, but they don't get TypeScript definitions */
+    namespace JSX {
+        interface IntrinsicElements {
+            'intelliweave-embed': any;
+        }
+    }
+}
+/** Provide the IntelliWeave object to all child components */
+declare function IntelliWeaveProvider(props: {
+    /** Optionally specify your own instance */
+    ai?: IntelliWeave;
+    /** Child components */
+    children: React.ReactNode;
+    /** API key generated on the IntelliWeave hub */
+    apiKey: string;
+    /** If true, conversations will be recorded on the Hub for analysis. If not specified, uses the value specified on the Hub. */
+    analytics?: boolean;
+    /** If true, shows debug information in the console */
+    debug?: boolean;
+}): React.JSX.Element;
+/** React hook to fetch IntelliWeave and be notified once it's loaded. Requires the `<IntelliWeaveProvider />` or `<WebWeaverUI />` component to exist somewhere in your scene graph. */
+declare function useIntelliWeave(): IntelliWeave | undefined;
+/** React hook to add an external KB search hook. This can provide static KB entries, or perform an async search and return dynamic entries. */
+/** React hook to add an external KB search hook. This can provide static KB entries, or perform an async search and return dynamic entries. */
+declare function useIntelliWeaveKnowledge(query: KnowledgeBaseSource['query'], dependencies?: any[]): void;
+
+export { IntelliWeaveProvider, WebWeaverUI, useIntelliWeave, useIntelliWeaveKnowledge };