@customer-agent/sdk 0.5.6-test.g260612164307

package/types/sdk/events.d.ts

@@ -0,0 +1,106 @@
+import { CUSTOMER_AGENT_INTERVIEW_STATUS, CustomerAgentInterviewState } from '../runtime/interview/interviewTypes';
+import { CustomerAgentSupportState } from '../runtime/support/supportTypes';
+import { CUSTOMER_AGENT_EVENTS } from './constants';
+type CustomerAgentEventBase<TType extends string> = {
+    appId: string;
+    timestamp: string;
+    type: TType;
+    widgetId: string;
+};
+type MessageRole = "assistant" | "user";
+type AssistantAuthor = "human" | "llm";
+export type CustomerAgentConversationType = "interview" | "support" | (string & {});
+type CustomerAgentConversationMeta = {
+    conversationId: string;
+    conversationType: CustomerAgentConversationType;
+    entryId: string;
+    interviewSessionId?: string;
+    supportConversationId?: string;
+};
+type OptionalCustomerAgentConversationMeta = Partial<CustomerAgentConversationMeta> & {
+    conversationType?: CustomerAgentConversationType;
+};
+type InterviewInvitationEvent = CustomerAgentEventBase<string> & {
+    campaignId: string;
+    entryId: string;
+    invitationId: string;
+};
+export type CustomerAgentEventMap = {
+    [CUSTOMER_AGENT_EVENTS.BUG_REPORTED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.BUG_REPORTED> & OptionalCustomerAgentConversationMeta;
+    [CUSTOMER_AGENT_EVENTS.CONVERSATION_CREATED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.CONVERSATION_CREATED> & CustomerAgentConversationMeta;
+    [CUSTOMER_AGENT_EVENTS.ERROR]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.ERROR> & {
+        message: string;
+    };
+    [CUSTOMER_AGENT_EVENTS.FEEDBACK_SUBMITTED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.FEEDBACK_SUBMITTED> & OptionalCustomerAgentConversationMeta & {
+        messageId?: string;
+    };
+    [CUSTOMER_AGENT_EVENTS.HANDOFF_REQUESTED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.HANDOFF_REQUESTED> & OptionalCustomerAgentConversationMeta;
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_INVITATION_CLOSED]: InterviewInvitationEvent;
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_INVITATION_LATER]: InterviewInvitationEvent;
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_INVITATION_SHOWN]: InterviewInvitationEvent;
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_AVAILABLE]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.INTERVIEW_AVAILABLE> & Extract<CustomerAgentInterviewState, {
+        status: typeof CUSTOMER_AGENT_INTERVIEW_STATUS.AVAILABLE;
+    }>;
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_REWARD_UPDATED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.INTERVIEW_REWARD_UPDATED> & Partial<CustomerAgentConversationMeta> & {
+        reward?: unknown;
+    };
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_STATE_CHANGED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.INTERVIEW_STATE_CHANGED> & {
+        interview: CustomerAgentInterviewState;
+    };
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_SESSION_COMPLETED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.INTERVIEW_SESSION_COMPLETED> & CustomerAgentConversationMeta & {
+        status?: string;
+    };
+    [CUSTOMER_AGENT_EVENTS.INTERVIEW_SESSION_STARTED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.INTERVIEW_SESSION_STARTED> & CustomerAgentConversationMeta;
+    [CUSTOMER_AGENT_EVENTS.MESSAGE_COMPLETED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.MESSAGE_COMPLETED> & CustomerAgentConversationMeta & {
+        assistantAuthor?: AssistantAuthor;
+        messageId: string;
+        role: MessageRole;
+    };
+    [CUSTOMER_AGENT_EVENTS.MESSAGE_FAILED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.MESSAGE_FAILED> & OptionalCustomerAgentConversationMeta & {
+        messageId?: string;
+        role: MessageRole;
+    };
+    [CUSTOMER_AGENT_EVENTS.MESSAGE_RETRY]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.MESSAGE_RETRY> & OptionalCustomerAgentConversationMeta & {
+        messageId?: string;
+        role: MessageRole;
+    };
+    [CUSTOMER_AGENT_EVENTS.MESSAGE_SEND_FAILED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.MESSAGE_SEND_FAILED> & OptionalCustomerAgentConversationMeta & {
+        messageId?: string;
+        role: MessageRole;
+    };
+    [CUSTOMER_AGENT_EVENTS.MESSAGE_SENT]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.MESSAGE_SENT> & OptionalCustomerAgentConversationMeta & {
+        messageId: string;
+        role: MessageRole;
+    };
+    [CUSTOMER_AGENT_EVENTS.MESSAGE_STARTED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.MESSAGE_STARTED> & CustomerAgentConversationMeta & {
+        messageId?: string;
+        role: MessageRole;
+    };
+    [CUSTOMER_AGENT_EVENTS.SUPPORT_STATE_CHANGED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.SUPPORT_STATE_CHANGED> & {
+        support: CustomerAgentSupportState;
+    };
+    [CUSTOMER_AGENT_EVENTS.TRANSCRIPT_DOWNLOADED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.TRANSCRIPT_DOWNLOADED> & OptionalCustomerAgentConversationMeta & {
+        conversationType: CustomerAgentConversationType;
+        messageCount: number;
+    };
+    [CUSTOMER_AGENT_EVENTS.WIDGET_CLOSED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.WIDGET_CLOSED>;
+    [CUSTOMER_AGENT_EVENTS.WIDGET_COLLAPSED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.WIDGET_COLLAPSED>;
+    [CUSTOMER_AGENT_EVENTS.WIDGET_EXPANDED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.WIDGET_EXPANDED>;
+    [CUSTOMER_AGENT_EVENTS.WIDGET_OPENED]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.WIDGET_OPENED>;
+    [CUSTOMER_AGENT_EVENTS.WIDGET_READY]: CustomerAgentEventBase<typeof CUSTOMER_AGENT_EVENTS.WIDGET_READY>;
+};
+export type CustomerAgentEventName = keyof CustomerAgentEventMap;
+export type CustomerAgentEventPayload<TEventName extends CustomerAgentEventName> = Omit<CustomerAgentEventMap[TEventName], "appId" | "timestamp" | "type" | "widgetId">;
+type OptionalEventName = {
+    [TEventName in CustomerAgentEventName]: keyof CustomerAgentEventPayload<TEventName> extends never ? TEventName : never;
+}[CustomerAgentEventName];
+type EmitEventArgs<TEventName extends CustomerAgentEventName> = TEventName extends OptionalEventName ? [eventName: TEventName, detail?: CustomerAgentEventPayload<TEventName>] : [eventName: TEventName, detail: CustomerAgentEventPayload<TEventName>];
+export type CustomerAgentEventBus = ReturnType<typeof createCustomerAgentEventBus>;
+export declare function createCustomerAgentEventBus(getBaseFields: () => {
+    appId: string;
+    widgetId: string;
+}): {
+    emit<TEventName extends CustomerAgentEventName>(...args: EmitEventArgs<TEventName>): void;
+    on<TEventName extends CustomerAgentEventName>(eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void): () => void;
+};
+export {};

package/types/sdk/hooks.d.ts

@@ -0,0 +1,37 @@
+import { RefObject } from 'react';
+import { CustomerAgentEventMap, CustomerAgentEventName } from './events';
+import { CustomerAgentGlobal, CustomerAgentState } from './public-types';
+type CustomerAgentHookController = {
+    CustomerAgent: CustomerAgentGlobal;
+    boot: CustomerAgentGlobal["boot"];
+    chooseInvitation: CustomerAgentGlobal["chooseInvitation"];
+    ensureInvitation: CustomerAgentGlobal["ensureInvitation"];
+    getInterviewSession: CustomerAgentGlobal["getInterviewSession"];
+    getInterviewState: CustomerAgentGlobal["getInterviewState"];
+    getSession: CustomerAgentGlobal["getSession"];
+    getState: CustomerAgentGlobal["getState"];
+    getSupportState: CustomerAgentGlobal["getSupportState"];
+    hide: CustomerAgentGlobal["hide"];
+    identify: CustomerAgentGlobal["identify"];
+    isOpen: boolean;
+    isReady: boolean;
+    launcher: CustomerAgentState["launcher"] | null;
+    launcherAnchor: HTMLElement | null;
+    launcherAnchorRef: RefObject<HTMLElement | null>;
+    loadInterviewReward: CustomerAgentGlobal["loadInterviewReward"];
+    on: CustomerAgentGlobal["on"];
+    openEntry: CustomerAgentGlobal["openEntry"];
+    sendInterviewMessage: CustomerAgentGlobal["sendInterviewMessage"];
+    setContext: CustomerAgentGlobal["setContext"];
+    show: CustomerAgentGlobal["show"];
+    shutdown: CustomerAgentGlobal["shutdown"];
+    startInterview: CustomerAgentGlobal["startInterview"];
+    startInvitation: CustomerAgentGlobal["startInvitation"];
+    state: CustomerAgentState | null;
+    toggle: CustomerAgentGlobal["toggle"];
+    update: CustomerAgentGlobal["update"];
+};
+export declare function useCustomerAgentState(): CustomerAgentState | null;
+export declare function useCustomerAgent(): CustomerAgentHookController;
+export declare function useCustomerAgentEvent<TEventName extends CustomerAgentEventName>(eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void): void;
+export {};

package/types/sdk/i18n.d.ts

@@ -0,0 +1,9 @@
+import { WidgetLocaleMessages } from '../types';
+export type ResolvedWidgetLocale = {
+    dir: "ltr" | "rtl";
+    locale: string;
+    messages: Required<WidgetLocaleMessages>;
+};
+export declare function resolveWidgetLocale(locale?: string, messageOverrides?: WidgetLocaleMessages): ResolvedWidgetLocale;
+export declare function loadWidgetLocale(locale?: string, messageOverrides?: WidgetLocaleMessages): Promise<ResolvedWidgetLocale>;
+export declare function formatWidgetMessage(message: string, values: Record<string, string>): string;

package/types/sdk/index.d.ts

@@ -0,0 +1,8 @@
+import { CustomerAgent } from './controller';
+export { boot, chooseInvitation, CustomerAgent, ensureInvitation, getInterviewState, getInterviewSession, getSession, getState, getSupportState, hide, identify, loadInterviewReward, on, openEntry, sendInterviewMessage, setContext, show, shutdown, startInterview, startInvitation, toggle, update } from './controller';
+export { CUSTOMER_AGENT_EVENTS } from './constants';
+export { INTERVIEW_INVITATION_ACTION } from '../runtime/interview/interviewTypes';
+export type { CustomerAgentEventMap, CustomerAgentEventName } from './events';
+export type { CustomerAgentGlobal, CustomerAgentInterviewInvitationAction, CustomerAgentInterviewInvitationChoice, CustomerAgentInterviewSession, CustomerAgentInterviewState, CustomerAgentOptions, CustomerAgentState, CustomerAgentSupportState, CustomerAgentTarget, CustomerAgentWidget, SetContextOptions } from './public-types';
+export type { WidgetContextJson } from '../types';
+export default CustomerAgent;

package/types/sdk/launcherAnchorStore.d.ts

@@ -0,0 +1,7 @@
+type LauncherAnchorListener = () => void;
+export declare function getLauncherAnchorSnapshot(): HTMLElement | null;
+export declare function getServerLauncherAnchorSnapshot(): null;
+export declare function subscribeLauncherAnchor(listener: LauncherAnchorListener): () => void;
+export declare function setLauncherAnchor(element: HTMLElement | null): void;
+export declare function clearLauncherAnchor(element?: HTMLElement | null): void;
+export {};

package/types/sdk/launcherState.d.ts

@@ -0,0 +1,21 @@
+import { WidgetViewport } from '../types';
+export type LauncherSyncState = {
+    activeEntryId?: string;
+    activeKind?: string;
+    hasInvitation?: boolean;
+    hasUnread?: boolean;
+    isOpen: boolean;
+    targetConnected: boolean;
+    targetConfigured: boolean;
+    viewport?: WidgetViewport["mode"] | WidgetViewport["presentation"];
+};
+export type ResolveLauncherElementOptions = {
+    createDefaultElement(): HTMLElement;
+    target?: HTMLElement | string | null;
+};
+export declare function resolveLauncherElement({ createDefaultElement, target }: ResolveLauncherElementOptions): {
+    launcherElement: HTMLElement;
+    targetConnected: boolean;
+    targetConfigured: boolean;
+};
+export declare function syncLauncherState(element: HTMLElement, state: LauncherSyncState): void;

package/types/sdk/navigationState.d.ts

@@ -0,0 +1,25 @@
+import { WidgetOptions } from '../types';
+import { CustomerAgentTarget } from './public-types';
+export declare const CUSTOMER_AGENT_MEMORY_ROUTE_TYPE: Readonly<{
+    CHAT: "chat";
+    SUPPORT: "support";
+}>;
+export type CustomerAgentMemoryRoute = {
+    entryId: string;
+    type: typeof CUSTOMER_AGENT_MEMORY_ROUTE_TYPE.CHAT;
+} | {
+    type: typeof CUSTOMER_AGENT_MEMORY_ROUTE_TYPE.SUPPORT;
+};
+export type CustomerAgentNavigationState = {
+    memoryRoute: CustomerAgentMemoryRoute;
+    requestedTarget?: CustomerAgentTarget;
+};
+export declare function getNavigationMemoryStorageKey(options: WidgetOptions): string;
+export declare function getDefaultMemoryRoute(): CustomerAgentMemoryRoute;
+export declare function isValidPublicEntryTargetId(entryId: string): boolean;
+export declare function createInitialNavigationState(options: WidgetOptions): CustomerAgentNavigationState;
+export declare function getEntryIdForMemoryRoute(route: CustomerAgentMemoryRoute): string | undefined;
+export declare function getMemoryRouteForTarget(target: CustomerAgentTarget): CustomerAgentMemoryRoute | null;
+export declare function setNavigationTarget(options: WidgetOptions, state: CustomerAgentNavigationState, target: CustomerAgentTarget | undefined): CustomerAgentNavigationState;
+export declare function commitMemoryRoute(options: WidgetOptions, state: CustomerAgentNavigationState, route: CustomerAgentMemoryRoute): CustomerAgentNavigationState;
+export declare function clearNavigationTarget(state: CustomerAgentNavigationState): CustomerAgentNavigationState;

package/types/sdk/public-types.d.ts

@@ -0,0 +1,152 @@
+import { CustomerAgentInterviewState, InterviewInvitationChoice, InterviewSessionResponse } from '../runtime/interview/interviewTypes';
+import { CustomerAgentSupportState } from '../runtime/support/supportTypes';
+import { WidgetContextJson, WidgetLauncherOptions, WidgetLauncherTarget, WidgetLocaleMessages, WidgetMobileOptions, WidgetTheme, WidgetUser } from '../types';
+import { CustomerAgentEventMap, CustomerAgentEventName } from './events';
+export type { CustomerAgentInterviewState } from '../runtime/interview/interviewTypes';
+export type { InterviewInvitationAction as CustomerAgentInterviewInvitationAction, InterviewInvitationChoice as CustomerAgentInterviewInvitationChoice } from '../runtime/interview/interviewTypes';
+export type { InterviewSessionResponse as CustomerAgentInterviewSession } from '../runtime/interview/interviewTypes';
+export type { CustomerAgentSupportState } from '../runtime/support/supportTypes';
+export type CustomerAgentOptions = {
+    app_id: string;
+    anonymous_id?: string;
+    brand?: {
+        name?: string;
+    };
+    context?: WidgetContextJson;
+    context_ready?: boolean;
+    launcher?: WidgetLauncherOptions & {
+        target?: WidgetLauncherTarget;
+    };
+    locale?: string;
+    messages?: WidgetLocaleMessages;
+    mobile?: WidgetMobileOptions;
+    mount?: HTMLElement | string;
+    open_on_init?: boolean;
+    position?: "bottom-right" | "bottom-left";
+    theme?: WidgetTheme;
+    user?: WidgetUser;
+};
+export type SetContextOptions = {
+    merge?: boolean;
+    ready?: boolean;
+};
+export type CustomerAgentState = {
+    activeEntryId?: string;
+    activeTarget?: CustomerAgentTarget;
+    appId: string;
+    isOpen: boolean;
+    isReady: boolean;
+    interview: CustomerAgentInterviewState;
+    launcher: {
+        targetConfigured: boolean;
+        targetConnected: boolean;
+    };
+    support: CustomerAgentSupportState;
+    widgetId: string;
+};
+export type CustomerAgentTarget = {
+    type: "entry";
+    entryId: string;
+} | {
+    type: "home";
+} | {
+    type: "interview";
+    campaignId?: string;
+    sessionId?: string;
+} | {
+    type: "support";
+};
+export type CustomerAgentWidget = {
+    chooseInvitation(invitationId: string, choice: InterviewInvitationChoice): Promise<void>;
+    ensureInvitation(): Promise<{
+        invitationId: string;
+    }>;
+    getInterviewState(): CustomerAgentInterviewState;
+    getInterviewSession(): InterviewSessionResponse | null;
+    getSession(): Promise<{
+        conversationId: string;
+    }>;
+    getState(): CustomerAgentState;
+    getSupportState(): CustomerAgentSupportState;
+    hide(): void;
+    identify(user: WidgetUser): void;
+    on<TEventName extends CustomerAgentEventName>(eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void): () => void;
+    openEntry(entryId: string): void;
+    loadInterviewReward(sessionId?: string): Promise<unknown>;
+    sendInterviewMessage(content: string): Promise<void>;
+    setContext(context: WidgetContextJson, options?: SetContextOptions): void;
+    show(target?: CustomerAgentTarget): void;
+    shutdown(): void;
+    startInterview(): Promise<{
+        entryId: string;
+        sessionId: string;
+    }>;
+    startInvitation(invitationId: string): Promise<{
+        entryId: string;
+        sessionId: string;
+    }>;
+    toggle(target?: CustomerAgentTarget): void;
+    update(options: Partial<CustomerAgentOptions>): void;
+};
+export type CustomerAgentGlobal = {
+    (command: "boot", options: CustomerAgentOptions): CustomerAgentWidget;
+    (command: "getSession"): Promise<{
+        conversationId: string;
+    } | null>;
+    (command: "getState"): CustomerAgentState | null;
+    (command: "getSupportState"): CustomerAgentSupportState | null;
+    (command: "getInterviewState"): CustomerAgentInterviewState | null;
+    (command: "getInterviewSession"): InterviewSessionResponse | null;
+    (command: "ensureInvitation"): Promise<{
+        invitationId: string;
+    } | null>;
+    (command: "startInvitation", invitationId: string): Promise<{
+        entryId: string;
+        sessionId: string;
+    } | null>;
+    (command: "startInterview"): Promise<{
+        entryId: string;
+        sessionId: string;
+    } | null>;
+    (command: "chooseInvitation", invitationId: string, choice: InterviewInvitationChoice): Promise<void>;
+    (command: "loadInterviewReward", sessionId?: string): Promise<unknown>;
+    (command: "sendInterviewMessage", content: string): Promise<void>;
+    (command: "identify", user: WidgetUser): void;
+    (command: "openEntry", entryId: string): void;
+    <TEventName extends CustomerAgentEventName>(command: "on", eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void): () => void;
+    (command: "setContext", context: WidgetContextJson, options?: SetContextOptions): void;
+    (command: "show" | "toggle", target?: CustomerAgentTarget): void;
+    (command: "update", options: Partial<CustomerAgentOptions>): void;
+    (command: "hide" | "shutdown"): void;
+    boot(options: CustomerAgentOptions): CustomerAgentWidget;
+    chooseInvitation(invitationId: string, choice: InterviewInvitationChoice): Promise<void>;
+    ensureInvitation(): Promise<{
+        invitationId: string;
+    } | null>;
+    getInterviewState(): CustomerAgentInterviewState | null;
+    getInterviewSession(): InterviewSessionResponse | null;
+    getSession(): Promise<{
+        conversationId: string;
+    } | null>;
+    getState(): CustomerAgentState | null;
+    getSupportState(): CustomerAgentSupportState | null;
+    hide(): void;
+    identify(user: WidgetUser): void;
+    on<TEventName extends CustomerAgentEventName>(eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void): () => void;
+    openEntry(entryId: string): void;
+    loadInterviewReward(sessionId?: string): Promise<unknown>;
+    sendInterviewMessage(content: string): Promise<void>;
+    setContext(context: WidgetContextJson, options?: SetContextOptions): void;
+    show(target?: CustomerAgentTarget): void;
+    shutdown(): void;
+    startInterview(): Promise<{
+        entryId: string;
+        sessionId: string;
+    } | null>;
+    startInvitation(invitationId: string): Promise<{
+        entryId: string;
+        sessionId: string;
+    } | null>;
+    toggle(target?: CustomerAgentTarget): void;
+    update(options: Partial<CustomerAgentOptions>): void;
+};

package/types/sdk/runtime.d.ts

@@ -0,0 +1,37 @@
+import { WidgetContextJson, WidgetUser } from '../types';
+import { CustomerAgentEventMap, CustomerAgentEventName } from './events';
+import { CustomerAgentGlobal, CustomerAgentInterviewInvitationChoice, CustomerAgentOptions, CustomerAgentState, CustomerAgentTarget, CustomerAgentWidget, SetContextOptions } from './public-types';
+export type { CustomerAgentGlobal, CustomerAgentWidget } from './public-types';
+declare function boot(options: CustomerAgentOptions): CustomerAgentWidget;
+export declare const CustomerAgent: CustomerAgentGlobal;
+export declare const chooseInvitation: (invitationId: string, choice: CustomerAgentInterviewInvitationChoice) => Promise<void>;
+export declare const ensureInvitation: () => Promise<{
+    invitationId: string;
+} | null>;
+export declare const getInterviewState: () => import('./public-types').CustomerAgentInterviewState | null;
+export declare const getInterviewSession: () => import('./public-types').CustomerAgentInterviewSession | null;
+export declare const getSession: () => Promise<{
+    conversationId: string;
+} | null>;
+export declare const getState: () => CustomerAgentState | null;
+export declare const getSupportState: () => import('./public-types').CustomerAgentSupportState | null;
+export declare const hide: () => void;
+export declare const identify: (user: WidgetUser) => void;
+export declare const on: <TEventName extends CustomerAgentEventName>(eventName: TEventName, handler: (event: CustomerAgentEventMap[TEventName]) => void) => () => void;
+export declare const openEntry: (entryId: string) => void;
+export declare const loadInterviewReward: (sessionId?: string) => Promise<unknown>;
+export declare const sendInterviewMessage: (content: string) => Promise<void>;
+export declare const setContext: (context: WidgetContextJson, options?: SetContextOptions) => void;
+export declare const show: (target?: CustomerAgentTarget) => void;
+export declare const shutdown: () => void;
+export declare const startInvitation: (invitationId: string) => Promise<{
+    entryId: string;
+    sessionId: string;
+} | null>;
+export declare const startInterview: () => Promise<{
+    entryId: string;
+    sessionId: string;
+} | null>;
+export declare const toggle: (target?: CustomerAgentTarget) => void;
+export declare const update: (options: Partial<CustomerAgentOptions>) => void;
+export { boot };

package/types/sdk/script.d.ts

@@ -0,0 +1,16 @@
+import { CustomerAgentGlobal } from './public-types';
+type QueuedCustomerAgentGlobal = {
+    q?: Array<ArrayLike<unknown>>;
+};
+type RuntimeGlobal = CustomerAgentGlobal & {
+    __customerAgentRuntime?: true;
+};
+type ScriptGlobal = CustomerAgentGlobal & {
+    __customerAgentScript?: true;
+};
+declare global {
+    interface Window {
+        CustomerAgent?: RuntimeGlobal | ScriptGlobal | QueuedCustomerAgentGlobal;
+    }
+}
+export {};

package/types/sdk/version.d.ts

@@ -0,0 +1,7 @@
+export declare const CUSTOMER_AGENT_VERSION: string;
+export declare function publishCustomerAgentVersion(): void;
+declare global {
+    interface Window {
+        __customerAgentVersion?: string;
+    }
+}

package/types/sdk/viewport.d.ts

@@ -0,0 +1,3 @@
+import { WidgetMobileOptions, WidgetViewport } from '../types';
+export declare function getSafeAreaBottom(): number;
+export declare function resolveViewport(mobile?: WidgetMobileOptions): WidgetViewport;

package/types/types.d.ts

@@ -0,0 +1,64 @@
+import { default as defaultLocaleMessages } from './messages/en.json';
+export type WidgetUser = {
+    id?: string;
+    email?: string;
+    name?: string;
+    [key: string]: unknown;
+};
+export type WidgetContextJson = Record<string, unknown>;
+export type WidgetLocaleMessages = Partial<Record<keyof typeof defaultLocaleMessages, string>>;
+export type WidgetMobileOptions = {
+    mode?: "auto" | "fullscreen" | "bottom-sheet";
+};
+export type WidgetMobilePresentation = "desktop" | "fullscreen" | "bottom-sheet";
+export type WidgetLauncherPlacement = "bottom" | "left" | "right" | "top";
+export type WidgetLauncherStyle = Record<string, number | string | undefined>;
+export type WidgetLauncherVariableName = "bg-color" | "border-color" | "border-radius" | "border-style" | "border-width" | "box-shadow" | "color" | "hover-bg-color" | "hover-border-color" | "hover-border-radius" | "hover-border-style" | "hover-border-width" | "hover-box-shadow" | "hover-color";
+export type WidgetLauncherVariables = Partial<Record<WidgetLauncherVariableName, number | string | undefined>>;
+export type WidgetLauncherOptions = {
+    offset?: number;
+    placement?: WidgetLauncherPlacement;
+    style?: WidgetLauncherStyle;
+    variables?: WidgetLauncherVariables;
+};
+export type WidgetLauncherTarget = HTMLElement | string;
+export type WidgetLauncherAnchor = {
+    panelHeight: number;
+    panelLeft: number;
+    panelTop: number;
+    panelWidth: number;
+    placement: WidgetLauncherPlacement;
+};
+export type WidgetTheme = {
+    colorScheme?: "light" | "dark" | "system";
+    primaryColor?: string;
+    radius?: number;
+};
+export type WidgetViewport = {
+    height: number;
+    isMobile: boolean;
+    keyboardInset: number;
+    mode: "desktop" | "mobile";
+    offsetTop: number;
+    presentation: WidgetMobilePresentation;
+    safeAreaBottom: number;
+    visualHeight: number;
+    width: number;
+};
+export type WidgetOptions = {
+    app_id: string;
+    widgetId: string;
+    anonymous_id?: string;
+    brand?: {
+        name?: string;
+    };
+    context?: WidgetContextJson;
+    context_ready?: boolean;
+    locale?: string;
+    launcher?: WidgetLauncherOptions;
+    messages?: WidgetLocaleMessages;
+    mobile?: WidgetMobileOptions;
+    open_on_init?: boolean;
+    theme?: WidgetTheme;
+    user?: WidgetUser;
+};

package/types/ui/App.d.ts

@@ -0,0 +1,55 @@
+import { InterviewInvitationChoice, InterviewSessionResponse } from '../runtime/interview/interviewTypes';
+import { CustomerAgentApiMessage } from '../sdk/apiClient';
+import { CurrentCustomerAgentOptions } from '../sdk/config';
+import { CustomerAgentEventBus } from '../sdk/events';
+import { ResolvedWidgetLocale } from '../sdk/i18n';
+import { CustomerAgentMemoryRoute } from '../sdk/navigationState';
+import { CustomerAgentInterviewState, CustomerAgentSupportState, CustomerAgentTarget } from '../sdk/public-types';
+import { WidgetViewport } from '../types';
+export declare function preloadWidgetPanelShell(): Promise<void>;
+export declare function createStableLauncherReference(element: HTMLElement): {
+    contextElement: HTMLElement;
+    getBoundingClientRect(): DOMRect;
+};
+export type WidgetAppProps = {
+    eventBus?: CustomerAgentEventBus;
+    activeTarget?: CustomerAgentTarget;
+    hasPanel: boolean;
+    hasCustomLauncher: boolean;
+    isOpen: boolean;
+    isViewportSettling?: boolean;
+    memoryRoute?: CustomerAgentMemoryRoute;
+    interviewRuntime?: {
+        chooseInvitation(id: string, choice: InterviewInvitationChoice): Promise<void>;
+        ensureInvitation(): Promise<string>;
+        getActiveSession(): InterviewSessionResponse | null;
+        startInvitation(id: string): Promise<{
+            entryId: string;
+            session: InterviewSessionResponse;
+            sessionId: string;
+        }>;
+    };
+    launcherTargetElement: HTMLElement | null;
+    onMemoryRouteChange?(route: CustomerAgentMemoryRoute): void;
+    onOpenChange(open: boolean): void;
+    options: CurrentCustomerAgentOptions;
+    resolvedLocale: ResolvedWidgetLocale;
+    runtimeState?: {
+        interview: CustomerAgentInterviewState;
+        support: CustomerAgentSupportState;
+    };
+    supportRuntime?: {
+        ensureSession(): Promise<{
+            conversationId: string;
+            messages: CustomerAgentApiMessage[];
+        }>;
+        getSessionSnapshot(): {
+            conversationId: string;
+            messages: CustomerAgentApiMessage[];
+        } | null;
+        invalidateSession?(): void;
+    };
+    viewport: WidgetViewport;
+    widgetId: string;
+};
+export declare function WidgetApp({ activeTarget, eventBus, hasPanel, hasCustomLauncher, isOpen, isViewportSettling, memoryRoute, interviewRuntime, launcherTargetElement, onMemoryRouteChange, onOpenChange, options, resolvedLocale, runtimeState, supportRuntime, viewport, widgetId }: WidgetAppProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/Iframe.d.ts

@@ -0,0 +1,16 @@
+import { ReactNode } from 'react';
+import { WidgetFrameAction, WidgetFrameState, WidgetSurface } from '../messages';
+export type WidgetIframeRenderProps = {
+    dispatch(action: WidgetFrameAction): void;
+    state: WidgetFrameState;
+};
+export type WidgetIframeProps = {
+    children(props: WidgetIframeRenderProps): ReactNode;
+    loadingFallback?(props: WidgetIframeRenderProps): ReactNode;
+    state: WidgetFrameState;
+    surface: WidgetSurface;
+    title: string;
+    widgetId: string;
+};
+export declare function preloadWidgetPanelStylesheet(): Promise<string>;
+export declare function WidgetIframe({ children, loadingFallback, state, surface, title, widgetId }: WidgetIframeProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/Launcher.d.ts

@@ -0,0 +1,12 @@
+import { CSSProperties } from 'react';
+import { ResolvedWidgetLocale } from '../sdk/i18n';
+import { WidgetOptions } from '../types';
+export type WidgetLauncherProps = {
+    bootOptions?: Partial<WidgetOptions> | null;
+    isOpen: boolean;
+    launcherVariableStyle?: CSSProperties;
+    locale: ResolvedWidgetLocale;
+    onOpenChange(open: boolean): void;
+    onPanelPreload?(): void;
+};
+export declare function WidgetLauncher({ bootOptions, isOpen, launcherVariableStyle, locale, onOpenChange, onPanelPreload }: WidgetLauncherProps): import("react/jsx-runtime").JSX.Element;

package/types/ui/MarkdownText.d.ts

@@ -0,0 +1 @@
+export declare function MarkdownText(): import("react/jsx-runtime").JSX.Element;

package/types/ui/Panel.d.ts

@@ -0,0 +1,52 @@
+import { InterviewInvitationChoice, InterviewSessionResponse } from '../runtime/interview/interviewTypes';
+import { CustomerAgentApiMessage } from '../sdk/apiClient';
+import { CustomerAgentEventBus } from '../sdk/events';
+import { ResolvedWidgetLocale } from '../sdk/i18n';
+import { CustomerAgentMemoryRoute } from '../sdk/navigationState';
+import { CustomerAgentInterviewState, CustomerAgentSupportState, CustomerAgentTarget } from '../sdk/public-types';
+import { WidgetOptions, WidgetViewport } from '../types';
+export type WidgetMessage = {
+    id: string;
+    author: "visitor" | "assistant";
+    text: string;
+};
+export type WidgetPanelProps = {
+    activeTarget?: CustomerAgentTarget;
+    bootOptions?: Partial<WidgetOptions> | null;
+    eventBus?: CustomerAgentEventBus;
+    interviewRuntime?: {
+        chooseInvitation(id: string, choice: InterviewInvitationChoice): Promise<void>;
+        ensureInvitation(): Promise<string>;
+        getActiveSession(): InterviewSessionResponse | null;
+        startInvitation(id: string): Promise<{
+            entryId: string;
+            session: InterviewSessionResponse;
+            sessionId: string;
+        }>;
+    };
+    isExpanded: boolean;
+    isOpen: boolean;
+    locale: ResolvedWidgetLocale;
+    messages?: WidgetMessage[];
+    memoryRoute?: CustomerAgentMemoryRoute;
+    onMemoryRouteChange?(route: CustomerAgentMemoryRoute): void;
+    onExpandedChange(expanded: boolean): void;
+    onOpenChange(open: boolean): void;
+    runtimeState?: {
+        interview: CustomerAgentInterviewState;
+        support: CustomerAgentSupportState;
+    };
+    supportRuntime?: {
+        ensureSession(): Promise<{
+            conversationId: string;
+            messages: CustomerAgentApiMessage[];
+        }>;
+        getSessionSnapshot(): {
+            conversationId: string;
+            messages: CustomerAgentApiMessage[];
+        } | null;
+        invalidateSession?(): void;
+    };
+    viewport: WidgetViewport;
+};
+export declare function WidgetPanel({ activeTarget, bootOptions, eventBus, interviewRuntime, isExpanded, isOpen, locale, memoryRoute, messages, onMemoryRouteChange, onExpandedChange, onOpenChange, runtimeState, supportRuntime, viewport }: WidgetPanelProps): import("react/jsx-runtime").JSX.Element;