@docyrus/ui-pro-ai-assistant 0.0.1 → 0.0.2

package/dist/internal/plate-editor/plate-ui/tooltip.d.ts

@@ -0,0 +1,19 @@
+import { type ComponentProps, type ComponentPropsWithoutRef, type ElementType, type ReactNode } from 'react';
+import { Tooltip as TooltipPrimitive } from 'radix-ui';
+export declare function TooltipProvider({ delayDuration, disableHoverableContent, skipDelayDuration, ...props }: ComponentProps<typeof TooltipPrimitive.Provider>): import("react/jsx-runtime").JSX.Element;
+export declare const Tooltip: import("react").FC<TooltipPrimitive.TooltipProps>;
+export declare const TooltipTrigger: import("react").ForwardRefExoticComponent<TooltipPrimitive.TooltipTriggerProps & import("react").RefAttributes<HTMLButtonElement>>;
+export declare const TooltipPortal: import("react").FC<TooltipPrimitive.TooltipPortalProps>;
+export declare function TooltipContent({ className, sideOffset, ...props }: ComponentProps<typeof TooltipPrimitive.Content>): import("react/jsx-runtime").JSX.Element;
+export declare function TooltipTC({ children, className, content, defaultOpen, delayDuration, disableHoverableContent, open, onOpenChange, ...props }: {
+    content: ReactNode;
+} & ComponentProps<typeof TooltipPrimitive.Content> & ComponentPropsWithoutRef<typeof TooltipPrimitive.Root>): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+type TooltipProps<T extends ElementType> = {
+    shortcut?: ReactNode;
+    tooltip?: ReactNode;
+    tooltipContentProps?: Omit<ComponentPropsWithoutRef<typeof TooltipPrimitive.Content>, 'children'>;
+    tooltipProps?: Omit<ComponentPropsWithoutRef<typeof TooltipPrimitive.Root>, 'children'>;
+    tooltipTriggerProps?: ComponentPropsWithoutRef<typeof TooltipPrimitive.Trigger>;
+} & ComponentProps<T>;
+export declare function withTooltip<T extends ElementType>(Component: T): ({ shortcut, tooltip, tooltipContentProps, tooltipProps, tooltipTriggerProps, ...props }: TooltipProps<T>) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/internal/plate-editor/plate-ui/turn-into-toolbar-button.d.ts

@@ -0,0 +1,63 @@
+import { type DropdownMenuProps } from './dropdown-menu';
+export declare const turnIntoItems: ({
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "p";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "h1";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "h2";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "h3";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "todo";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "disc";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "decimal";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "toggle";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "code_block";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "blockquote";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    keywords: string[];
+    label: string;
+    value: "callout";
+} | {
+    icon: import("react/jsx-runtime").JSX.Element;
+    label: string;
+    value: string;
+    keywords?: undefined;
+})[];
+export declare function TurnIntoToolbarButton(props: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/plate-editor/types/index.d.ts

@@ -0,0 +1 @@
+export type { MyBlockElement, MyBlockquoteElement, MyCodeBlockElement, MyCodeLineElement, MyH1Element, MyH2Element, MyH3Element, MyHrElement, MyImageElement, MyLinkElement, MyMentionElement, MyNestableBlock, MyParagraphElement, MyTableCellElement, MyTableElement, MyTableRowElement, MyTextBlockElement, MyToggleElement, MyValue, RichText } from '../editor/plate-types';

package/dist/internal/plate-editor/vite.d.ts

@@ -0,0 +1,4 @@
+import { type Plugin } from 'vite';
+export declare function handleAiCommand(request: Request, env: Record<string, string>): Promise<Response>;
+export declare function handleAiCopilot(request: Request, env: Record<string, string>): Promise<Response>;
+export declare function plateEditorPlugin(): Plugin;

package/dist/internal/sheets/components/univer-sheets.d.ts

@@ -0,0 +1,61 @@
+import '@univerjs/sheets/facade';
+import '@univerjs/sheets-ui/facade';
+import '@univerjs/sheets-numfmt/facade';
+import '@univerjs/sheets-data-validation/facade';
+import '@univerjs/sheets-conditional-formatting/facade';
+import '@univerjs/sheets-filter/facade';
+import '@univerjs/sheets-sort/facade';
+import '@univerjs/sheets-hyper-link/facade';
+import '@univerjs/sheets-find-replace/facade';
+import '@univerjs/sheets-thread-comment/facade';
+import '@univerjs/sheets-drawing-ui/facade';
+import '@univerjs/watermark/facade';
+import '@univerjs/sheets-crosshair-highlight/facade';
+import '@univerjs/design/lib/index.css';
+import '@univerjs/ui/lib/index.css';
+import '@univerjs/docs-ui/lib/index.css';
+import '@univerjs/sheets-ui/lib/index.css';
+import '@univerjs/sheets-formula-ui/lib/index.css';
+import '@univerjs/sheets-numfmt-ui/lib/index.css';
+import '@univerjs/drawing-ui/lib/index.css';
+import '@univerjs/sheets-drawing-ui/lib/index.css';
+import '@univerjs/sheets-data-validation-ui/lib/index.css';
+import '@univerjs/sheets-conditional-formatting-ui/lib/index.css';
+import '@univerjs/sheets-filter-ui/lib/index.css';
+import '@univerjs/sheets-sort-ui/lib/index.css';
+import '@univerjs/sheets-hyper-link-ui/lib/index.css';
+import '@univerjs/sheets-thread-comment-ui/lib/index.css';
+import '@univerjs/sheets-crosshair-highlight/lib/index.css';
+import { type Locale } from '../i18n/types';
+export interface SheetsPayload {
+    workbookData?: Record<string, unknown>;
+    user?: {
+        tenantId?: string;
+        name?: string;
+    };
+    recordId?: string;
+    versionId?: string;
+}
+export interface IApiCallPayload {
+    id?: string;
+    method: string;
+    args?: unknown[];
+}
+export interface UniverSheetsProps {
+    /** Initial workbook data to load */
+    initialData?: unknown;
+    /** Locale for UI translations (default: "en") */
+    locale?: Locale;
+    /** Commands to execute after the workbook loads */
+    commands?: IApiCallPayload[];
+    onReady?: () => void;
+    onData?: (data: {
+        workbook: unknown;
+        workbookJson: string;
+    }) => void;
+    onLoaded?: (data: {
+        workbookId: string;
+    }) => void;
+    onError?: (error: string) => void;
+}
+export declare function UniverSheets({ initialData, locale, commands, onReady, onData, onLoaded, onError: _onError }: UniverSheetsProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/sheets/i18n/context.d.ts

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+import { type DeepPartial, type I18nContextValue, type Locale, type SheetsTranslations } from './types';
+export declare const SheetsI18nContext: import("react").Context<I18nContextValue | null>;
+export interface SheetsI18nProviderProps {
+    locale?: Locale;
+    apiUrl?: string;
+    translations?: DeepPartial<SheetsTranslations>;
+    disableApi?: boolean;
+    children: ReactNode;
+}
+export declare function SheetsI18nProvider({ locale: initialLocale, apiUrl, translations: customTranslations, disableApi, children }: SheetsI18nProviderProps): import("react/jsx-runtime").JSX.Element;

package/dist/internal/sheets/i18n/index.d.ts

@@ -0,0 +1,13 @@
+export type { SheetsI18nProviderProps } from './context';
+export { SheetsI18nContext, SheetsI18nProvider } from './context';
+export { default as sheetsDe } from './locales/de.json';
+export { default as sheetsEl } from './locales/el.json';
+export { default as sheetsEn } from './locales/en.json';
+export { default as sheetsEs } from './locales/es.json';
+export { default as sheetsFr } from './locales/fr.json';
+export { default as sheetsIt } from './locales/it.json';
+export { default as sheetsPt } from './locales/pt.json';
+export { default as sheetsSl } from './locales/sl.json';
+export { default as sheetsTr } from './locales/tr.json';
+export type { DeepPartial, I18nConfig, I18nContextValue, Locale, SheetsTranslations } from './types';
+export { useSheetsTranslation } from './use-translation';

package/dist/internal/sheets/i18n/types.d.ts

@@ -0,0 +1,18 @@
+import type en from './locales/en.json';
+export type Locale = 'de' | 'el' | 'en' | 'es' | 'fr' | 'it' | 'pt' | 'sl' | 'tr';
+export type SheetsTranslations = typeof en;
+export type DeepPartial<T> = {
+    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
+};
+export interface I18nConfig {
+    locale: Locale;
+    apiUrl?: string;
+    translations?: DeepPartial<SheetsTranslations>;
+    disableApi?: boolean;
+}
+export interface I18nContextValue {
+    locale: Locale;
+    t: (key: string, params?: Record<string, string | number>) => string;
+    setLocale: (locale: Locale) => void;
+    isLoading: boolean;
+}

package/dist/internal/sheets/i18n/use-translation.d.ts

@@ -0,0 +1,2 @@
+import { type I18nContextValue } from './types';
+export declare function useSheetsTranslation(): I18nContextValue;

package/dist/internal/sheets/index.d.ts

@@ -0,0 +1,5 @@
+export type { IApiCallPayload, SheetsPayload, UniverSheetsProps } from './components/univer-sheets';
+export { UniverSheets } from './components/univer-sheets';
+export * from './i18n';
+export type { AIWorkbookData, AIWorkbookOutput, IWorkbookData } from './types';
+export * from './xlsx';

package/dist/internal/sheets/types/index.d.ts

@@ -0,0 +1,259 @@
+/**
+ * Sheets Type Definitions
+ * Matches univer-sheets-schema.json
+ */
+export interface IWorkbookData {
+    id: string;
+    name: string;
+    locale?: string;
+    sheetOrder: string[];
+    sheets: Record<string, IWorksheetData>;
+    styles?: Record<string, IStyleData>;
+    resources?: Array<{
+        name: string;
+        data: string;
+    }>;
+}
+export interface IWorksheetData {
+    id: string;
+    name: string;
+    tabColor?: string;
+    hidden?: 0 | 1;
+    rowCount: number;
+    columnCount: number;
+    defaultColumnWidth?: number;
+    defaultRowHeight?: number;
+    showGridlines?: 0 | 1;
+    freeze?: IFreeze;
+    cellData: ICellDataMatrix;
+    rowData?: Record<number, IRowData>;
+    columnData?: Record<number, IColumnData>;
+    mergeData?: IMergeRange[];
+    dataValidations?: IDataValidationRule[];
+    conditionalFormattingRules?: IConditionalFormattingRule[];
+    autoFilter?: IAutoFilter;
+}
+export type ICellDataMatrix = Record<number, Record<number, ICellData>>;
+export interface ICellData {
+    v?: string | number | boolean;
+    t?: 1 | 2 | 3 | 4;
+    f?: string;
+    s?: string | IStyleData;
+    p?: IRichTextData;
+    custom?: Record<string, unknown>;
+}
+export interface IRichTextData {
+    body: {
+        dataStream: string;
+        textRuns?: Array<{
+            st: number;
+            ed: number;
+            ts: ITextStyle;
+        }>;
+    };
+}
+export interface ITextStyle {
+    bl?: 0 | 1;
+    it?: 0 | 1;
+    ul?: {
+        s: number;
+    };
+    st?: {
+        s: number;
+    };
+    fs?: number;
+    ff?: string;
+    cl?: IColorStyle;
+}
+export interface IStyleData {
+    ff?: string;
+    fs?: number;
+    bl?: 0 | 1;
+    it?: 0 | 1;
+    ul?: {
+        s: number;
+    };
+    st?: {
+        s: number;
+    };
+    cl?: IColorStyle;
+    bg?: IColorStyle;
+    ht?: 1 | 2 | 3;
+    vt?: 1 | 2 | 3;
+    tb?: 1 | 2 | 3;
+    tr?: {
+        a?: number;
+        v?: 0 | 1;
+    };
+    pd?: {
+        t?: number;
+        b?: number;
+        l?: number;
+        r?: number;
+    };
+    bd?: IBorderData;
+    n?: {
+        pattern: string;
+    };
+}
+export interface IColorStyle {
+    rgb?: string;
+    th?: string;
+}
+export interface IBorderData {
+    t?: IBorderStyle;
+    b?: IBorderStyle;
+    l?: IBorderStyle;
+    r?: IBorderStyle;
+}
+export interface IBorderStyle {
+    s: number;
+    cl: IColorStyle;
+}
+export interface IRowData {
+    h?: number;
+    hd?: 0 | 1;
+    ia?: 0 | 1;
+}
+export interface IColumnData {
+    w?: number;
+    hd?: 0 | 1;
+}
+export interface IFreeze {
+    xSplit: number;
+    ySplit: number;
+    startRow: number;
+    startColumn: number;
+}
+export interface IMergeRange {
+    startRow: number;
+    startColumn: number;
+    endRow: number;
+    endColumn: number;
+}
+export interface IDataValidationRule {
+    uid: string;
+    type: 'list' | 'listMultiple' | 'checkbox' | 'custom' | 'decimal' | 'whole' | 'date' | 'textLength';
+    ranges: IMergeRange[];
+    formula1?: string;
+    formula2?: string;
+    operator?: string;
+    allowBlank?: boolean;
+    showErrorMessage?: boolean;
+    errorStyle?: 'stop' | 'warning' | 'information';
+    errorTitle?: string;
+    error?: string;
+    showInputMessage?: boolean;
+    promptTitle?: string;
+    prompt?: string;
+}
+export interface IConditionalFormattingRule {
+    cfId: string;
+    ranges: IMergeRange[];
+    stopIfTrue?: boolean;
+    rule: {
+        type: string;
+        subType?: string;
+        operator?: string;
+        value?: unknown;
+        value2?: unknown;
+        formula?: string;
+        style?: IStyleData;
+    };
+}
+export interface IFilterColumn {
+    colId: number;
+    filters?: {
+        filters?: string[];
+        blank?: boolean;
+    };
+}
+export interface IAutoFilter {
+    ref: IMergeRange;
+    filterColumns?: IFilterColumn[];
+}
+export interface AIWorkbookOutput {
+    title: string;
+    description: string;
+    assumptions: string[] | null;
+    warnings: string[] | null;
+    workbook: AIWorkbookData;
+    workbookData?: AIWorkbookData;
+}
+export interface AIWorkbookData {
+    id: string;
+    name: string;
+    appVersion?: string | null;
+    locale?: string | null;
+    sheetOrder: string[];
+    sheets: AISheetEntry[];
+    styles?: AIStyleEntry[] | null;
+    watermark?: IWatermark | null;
+}
+export interface AISheetEntry {
+    id: string;
+    sheet: AIWorksheetData;
+}
+export interface AIStyleEntry {
+    id: string;
+    style: IStyleData;
+}
+export interface AIWorksheetData {
+    id: string;
+    name: string;
+    tabColor?: string | null;
+    hidden?: 0 | 1 | null;
+    rowCount: number;
+    columnCount: number;
+    defaultColumnWidth?: number | null;
+    defaultRowHeight?: number | null;
+    showGridlines?: 0 | 1 | null;
+    rightToLeft?: 0 | 1 | null;
+    freeze?: IFreeze | null;
+    cellData: (ICellData | null)[][];
+    rowData?: AIRowData[] | null;
+    columnData?: AIColumnData[] | null;
+    rowHeader?: {
+        width?: number | null;
+        hidden?: 0 | 1 | null;
+    } | null;
+    columnHeader?: {
+        height?: number | null;
+        hidden?: 0 | 1 | null;
+    } | null;
+    mergeData?: IMergeRange[] | null;
+    dataValidations?: IDataValidationRule[] | null;
+    conditionalFormattingRules?: IConditionalFormattingRule[] | null;
+    autoFilter?: IAutoFilter | null;
+    comments?: IThreadComment[] | null;
+}
+export interface AIRowData {
+    row: number;
+    h?: number | null;
+    hd?: 0 | 1 | null;
+}
+export interface AIColumnData {
+    col: number;
+    w?: number | null;
+    hd?: 0 | 1 | null;
+}
+export interface IWatermark {
+    type: 'text' | 'image';
+    text?: string | null;
+    imageUrl?: string | null;
+    fontSize?: number | null;
+    color?: string | null;
+    opacity?: number | null;
+    rotate?: number | null;
+    repeat?: boolean | null;
+}
+export interface IThreadComment {
+    id: string;
+    ref: string;
+    dT?: string | null;
+    personId?: string | null;
+    text: {
+        dataStream: string;
+    };
+    resolved?: boolean | null;
+}

package/dist/internal/sheets/xlsx.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Browser-compatible XLSX ↔ Univer Converter
+ *
+ * Uses SheetJS (xlsx) for browser-side Excel file processing.
+ * Works in both browser and Cloudflare Workers (no Node.js dependencies).
+ */
+import { type AIWorkbookOutput, type IWorkbookData } from './types';
+export interface XlsxToUniverOptions {
+    workbookId?: string;
+    workbookName?: string;
+}
+export declare function xlsxToUniver(data: ArrayBuffer | Uint8Array, options?: XlsxToUniverOptions): IWorkbookData;
+export declare function univerToXlsx(data: IWorkbookData): ArrayBuffer;
+export declare function csvToUniver(csvContent: string, options?: {
+    delimiter?: string;
+    sheetName?: string;
+    workbookName?: string;
+    firstRowIsHeader?: boolean;
+}): IWorkbookData;
+export declare function univerToCsv(data: IWorkbookData, sheetId?: string): string;
+export declare function fileToUniver(file: File): Promise<IWorkbookData>;
+export declare function univerToBlob(data: IWorkbookData, format?: 'xlsx' | 'csv'): Blob;
+export declare function downloadWorkbook(data: IWorkbookData, filename: string, format?: 'xlsx' | 'csv'): void;
+/**
+ * Convert AI output (array-based format) to Univer native format (sparse matrix)
+ *
+ * @param aiOutput - The AI-generated workbook data in array-based format
+ * @returns Univer-compatible IWorkbookData in sparse matrix format
+ */
+export declare function aiOutputToUniver(aiOutput: AIWorkbookOutput): IWorkbookData;
+/**
+ * Validate AI output structure before conversion
+ *
+ * @param data - Raw parsed JSON from AI
+ * @returns Validation result with errors if any
+ */
+export declare function validateAIOutput(data: unknown): {
+    valid: boolean;
+    errors: string[];
+};

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

@@ -0,0 +1,17 @@
+export interface ApiResponse {
+    success: boolean;
+    data: unknown;
+    error?: string;
+    error_description?: string;
+}
+/**
+ * Hook to create an API client for the assistant
+ * Uses @docyrus/api-client with AsyncTokenManager
+ */
+export declare function useApiClient(): {
+    get: <T = unknown>(endpoint: string, params?: Record<string, unknown>) => Promise<ApiResponse>;
+    post: (endpoint: string, body?: unknown) => Promise<ApiResponse>;
+    put: (endpoint: string, body?: unknown) => Promise<ApiResponse>;
+    patch: (endpoint: string, body?: unknown) => Promise<ApiResponse>;
+    delete: (endpoint: string) => Promise<ApiResponse>;
+};

package/dist/lib/assistant-api-actions.d.ts

@@ -0,0 +1,57 @@
+import { type ProjectState } from '../hooks/use-project-state';
+import { type SessionState } from '../hooks/use-session-state';
+import { type AssistantSession, type Project, type Work } from '../types';
+type ApiClient = {
+    get: (url: string, params?: any) => Promise<any>;
+    post: (url: string, data?: any) => Promise<any>;
+    patch: (url: string, data?: any) => Promise<any>;
+    delete: (url: string) => Promise<any>;
+};
+type TranslationFn = (key: string) => string;
+export declare function fetchAgentThreads(apiClient: ApiClient, tenantAiAgentId: string, onSuccess: (threads: AssistantSession[]) => void, userId?: string | null, deploymentId?: string | null): Promise<void>;
+export declare function fetchProjectThreads(apiClient: ApiClient, projectId: string, onSuccess: (projectId: string, threads: AssistantSession[]) => void): Promise<void>;
+export declare function fetchProjectWorks(apiClient: ApiClient, projectId: string, onSuccess: (projectId: string, works: Work[]) => void, tenantAiAgentId?: string, userId?: string | null): Promise<void>;
+export declare function fetchProjects(apiClient: ApiClient, userId: string | null, onSuccess: (projects: Project[]) => void, onProjectLoaded: (project: Project) => void, onComplete: () => void, tenantAiAgentId?: string): Promise<void>;
+export declare function fetchWorks(apiClient: ApiClient, onSuccess: (works: Work[]) => void, tenantAiAgentId?: string, userId?: string | null): Promise<void>;
+export declare function loadThreadMessages(apiClient: ApiClient, threadId: string, setMessages: (messages: any[]) => void): Promise<void>;
+export declare function updateProject(apiClient: ApiClient, projectState: ProjectState, projectActions: {
+    setSaving: (saving: boolean) => void;
+    stopEditing: () => void;
+}, refreshProjects: () => void, t: TranslationFn): Promise<void>;
+export declare function deleteProject(apiClient: ApiClient, projectState: ProjectState, projectActions: {
+    setDeleteDialogOpen: (open: boolean) => void;
+    setDeleting: (deleting: boolean) => void;
+}, refreshProjects: () => void, t: TranslationFn): Promise<void>;
+export declare function updateSession(apiClient: ApiClient, sessionState: SessionState, sessionActions: {
+    setSaving: (saving: boolean) => void;
+    stopEditing: () => void;
+}, refreshThreads: () => void, refreshProjectThreads: (projectId: string) => void, projectContextId: string | null, selectedProjectId: string | null, t: TranslationFn): Promise<void>;
+export declare function deleteSession(apiClient: ApiClient, sessionState: SessionState, sessionActions: {
+    setDeleteDialogOpen: (open: boolean) => void;
+    setDeleting: (deleting: boolean) => void;
+}, refreshThreads: () => void, refreshProjectThreads: (projectId: string) => void, projectContextId: string | null, selectedProjectId: string | null, t: TranslationFn): Promise<void>;
+export declare function updateProjectInstructions(apiClient: ApiClient, projectState: ProjectState, projectActions: {
+    setSavingInstructions: (saving: boolean) => void;
+    stopEditingInstructions: () => void;
+    updateProject: (project: Project) => void;
+}, refreshProjects: () => void, t: TranslationFn): Promise<void>;
+export declare function createThread(apiClient: ApiClient, data: {
+    subject: string;
+    body_text: string;
+    sender_name: string;
+    deploymentId?: string;
+    tenantAiAgentId: string;
+    projectId?: string | null;
+}): Promise<{
+    id: string;
+    subject: string;
+    created_on: string;
+    last_modified_on: string;
+} | null>;
+export declare function uploadThreadFile(apiClient: ApiClient, threadId: string, file: File): Promise<string | null>;
+export declare function createProject(apiClient: ApiClient, data: {
+    name: string;
+    description?: string;
+    tenantAiAgentId: string;
+}, onSuccess: (project: any) => void, onComplete: () => void): Promise<void>;
+export {};

package/dist/lib/assistant-config.d.ts

@@ -0,0 +1,39 @@
+import { type ReactNode } from 'react';
+export interface AssistantUser {
+    id: string;
+    email?: string;
+    firstname?: string;
+    lastname?: string;
+    photo?: string;
+}
+export interface DataSourceField {
+    id: string;
+    name: string;
+    slug: string;
+    type: string;
+    read_only?: boolean;
+    sort_order?: number;
+}
+export interface DataSourceSchema {
+    id: string;
+    name: string;
+    slug: string;
+    app: {
+        id: string;
+        name: string;
+        slug: string;
+    };
+    fields: DataSourceField[];
+}
+export interface AssistantConfig {
+    apiBaseUrl: string;
+    getAuthToken: () => Promise<string>;
+    user?: AssistantUser | null;
+    getDataSourceSchema?: (id: string) => Promise<DataSourceSchema | null>;
+}
+export interface AssistantProviderProps {
+    config: AssistantConfig;
+    children: ReactNode;
+}
+export declare function AssistantProvider({ config, children }: AssistantProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare function useAssistantConfig(): AssistantConfig;

package/dist/lib/class-utils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * CSS class utility functions for assistant dialog/container styling
+ */
+interface DialogClassOptions {
+    isExpanded: boolean;
+    isDocked: boolean;
+}
+interface ContainerClassOptions {
+    isExpanded: boolean;
+    isDocked: boolean;
+}
+/**
+ * Returns the appropriate className for the dialog based on its state
+ * Handles expanded, docked, and default states
+ */
+export declare function getDialogClassName({ isExpanded, isDocked }: DialogClassOptions): string;
+/**
+ * Returns the appropriate className for the container based on its state
+ * Handles rounded corners and overflow for different display modes
+ */
+export declare function getContainerClassName({ isExpanded, isDocked }: ContainerClassOptions): string;
+export {};

package/dist/lib/index.d.ts

@@ -0,0 +1,7 @@
+export { useApiClient } from './api-client';
+export type { ApiResponse } from './api-client';
+export { AssistantProvider, useAssistantConfig } from './assistant-config';
+export type { AssistantConfig, AssistantProviderProps, AssistantUser } from './assistant-config';
+export { getContainerClassName, getDialogClassName } from './class-utils';
+export { processMessagesData } from './message-utils';
+export type { ProcessedMessage } from './message-utils';