import { ComponentChild } from 'preact';

declare type AnyTool = Tool<any, any>;

declare type AsyncRenderToolResult = RenderToolResult | Promise<RenderToolResult>;

export declare const clearChat: () => void;

export declare interface Config {
    apiUrl: string;
    accountId: string;
    agentId: string;
    actorId?: string;
    context?: Record<string, unknown>;
    addToCart?: (product: Product) => void;
    tools?: AnyTool[];
    disabledTools?: DefaultToolName[] | '*';
    ui?: UiConfig;
    loadConfigFromApi?: boolean;
}

declare const DEFAULT_TOOL_NAMES: readonly ["retrieve_page_context", "display_products"];

export declare type DefaultToolName = (typeof DEFAULT_TOOL_NAMES)[number];

export declare const initialize: (config: Config) => Promise<void>;

declare interface Product {
    id: string;
    title: string;
    url: string;
    imageUrl?: string;
    price?: number;
    salePrice?: number;
    rating?: number;
    brand?: string;
    sku?: string;
    description?: string;
}

export declare interface RenderToolData<TInput> {
    input: TInput;
    status: ToolRenderStatus | undefined;
}

export declare interface RenderToolHelpers {
    sendMessage: (text: string) => Promise<void>;
}

export declare type RenderToolResult = ComponentChild | HTMLElement | null;

export declare const sendMessage: (message?: string, files?: File[]) => Promise<void>;

export declare const setActorId: (value: string | undefined) => void;

export declare const setContext: (context: Record<string, unknown> | undefined) => void;

export declare const toggle: (open: boolean) => void;

export declare interface Tool<TInput, TOutput> {
    name: string;
    description: string;
    inputSchema: {
        type: 'object';
        properties: Record<string, unknown>;
        required?: string[];
    };
    execute: (input: TInput, options?: ToolExecuteOptions) => Promise<TOutput>;
    render?: (data: RenderToolData<TInput>, helpers: RenderToolHelpers) => AsyncRenderToolResult;
}

export declare interface ToolExecuteOptions {
    signal?: AbortSignal;
}

export declare type ToolRenderStatus = 'pending' | 'success' | 'error';

export declare interface UiConfig {
    open?: boolean;
    display?: 'window' | 'drawer';
    position?: 'left' | 'right';
    theme?: 'light' | 'dark' | 'auto';
    allowFullScreen?: boolean;
    allowFileUpload?: boolean;
    logoUrl?: string;
    heading?: string;
    initialMessage?: string;
    promptOptions?: string[];
    placeholder?: string;
    showDisclaimer?: boolean;
    disclaimer?: string;
    colors?: {
        primary?: {
            default: string;
            hover: string;
        };
        focus?: {
            light?: string;
            dark?: string;
        };
    };
    styles?: string;
    stylesheetUrl?: string;
}

export { }


declare global {
    interface HawkAINamespace {
        Assistant: {
            config: Config;
            initialize: (config: Config) => Promise<void>;
            setActorId: (value: string | undefined) => void;
            setContext: (context: Record<string, unknown> | undefined) => void;
            toggle: (open: boolean) => void;
            sendMessage: (message?: string, files?: File[]) => Promise<void>;
            clearChat: () => void;
        };
    }
    interface Window {
        HawkAI: HawkAINamespace;
    }
}