@absolutejs/voice 0.0.22-beta.500 → 0.0.22-beta.502

package/dist/angular/voice-cost-dashboard.service.d.ts

@@ -0,0 +1,15 @@
+import type { StoredVoiceTraceEvent } from "../trace";
+import { type VoiceCostDashboardOptions, type VoiceCostDashboardReport } from "../client/costDashboard";
+export type VoiceCostDashboardServiceOptions = VoiceCostDashboardOptions & {
+    currency?: string;
+    title?: string;
+};
+export declare class VoiceCostDashboardService {
+    build(options: VoiceCostDashboardServiceOptions): {
+        currency: string;
+        report: import("@angular/core").Signal<VoiceCostDashboardReport>;
+        setEvents: (next: ReadonlyArray<StoredVoiceTraceEvent>) => void;
+        setFilters: (next: Partial<typeof options>) => void;
+        title: string;
+    };
+}

package/dist/angular/voice-live-call-viewer.service.d.ts

@@ -0,0 +1,16 @@
+import { type CreateLiveCallViewerOptions, type LiveCallViewState, type LiveCallViewer } from "../client/liveCallViewer";
+export type VoiceLiveCallViewerServiceOptions = CreateLiveCallViewerOptions & {
+    title?: string;
+    viewer?: LiveCallViewer;
+};
+export declare class VoiceLiveCallViewerService {
+    build(options: VoiceLiveCallViewerServiceOptions): {
+        noteAgentAudio: (at?: number) => void;
+        notePartial: (text: string, at?: number) => void;
+        noteTranscript: (text: string, at?: number) => void;
+        reset: (sessionId: string, startedAt?: number) => void;
+        state: import("@angular/core").Signal<LiveCallViewState>;
+        stop: () => void;
+        title: string;
+    };
+}

package/dist/angular/voice-replay-timeline.service.d.ts

@@ -0,0 +1,13 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+import { type ReplayTimelineReport } from "../client/replayTimeline";
+export type VoiceReplayTimelineServiceOptions = {
+    artifact: VoiceCallReviewArtifact;
+    title?: string;
+};
+export declare class VoiceReplayTimelineService {
+    build(options: VoiceReplayTimelineServiceOptions): {
+        report: import("@angular/core").Signal<ReplayTimelineReport>;
+        setArtifact: (next: VoiceCallReviewArtifact) => void;
+        title: string | undefined;
+    };
+}

package/dist/client/htmxDashboardRenderers.d.ts

@@ -0,0 +1,80 @@
+import type { StoredVoiceTraceEvent } from "../trace";
+import type { VoiceCallReviewArtifact } from "../testing/review";
+import { type VoiceCostDashboardBucket, type VoiceCostDashboardOptions, type VoiceCostDashboardReport } from "./costDashboard";
+import { type LiveCallViewState, type LiveCallViewer } from "./liveCallViewer";
+import { type ReplayTimelineReport } from "./replayTimeline";
+export type VoiceDashboardHTMXAttributes = {
+    /** Set true to wrap the fragment in an hx-get + hx-trigger="every Ns" polling shell. */
+    poll?: boolean;
+    /** Polling cadence when poll is true. Default 5 seconds. */
+    pollIntervalMs?: number;
+    /** Route the renderer points hx-get at. Default mirrors the route the handler is mounted on. */
+    refreshUrl?: string;
+    /** hx-swap value. Default 'outerHTML'. */
+    swap?: string;
+};
+export type VoiceCostDashboardHTMXInput = {
+    attributes?: VoiceDashboardHTMXAttributes;
+    currency?: string;
+    emptyMessage?: string;
+    report: VoiceCostDashboardReport;
+    title?: string;
+};
+export type VoiceCostDashboardRenderer = (input: VoiceCostDashboardHTMXInput) => string;
+export type VoiceCostDashboardCellRenderer = (bucket: VoiceCostDashboardBucket, currency: string, isTotal: boolean) => string;
+export type VoiceReplayTimelineHTMXInput = {
+    attributes?: VoiceDashboardHTMXAttributes;
+    emptyMessage?: string;
+    report: ReplayTimelineReport;
+    title?: string;
+};
+export type VoiceReplayTimelineRenderer = (input: VoiceReplayTimelineHTMXInput) => string;
+export type VoiceLiveCallViewerHTMXInput = {
+    attributes?: VoiceDashboardHTMXAttributes;
+    state: LiveCallViewState;
+    title?: string;
+};
+export type VoiceLiveCallViewerRenderer = (input: VoiceLiveCallViewerHTMXInput) => string;
+export type VoiceDashboardHTMXRendererConfig = {
+    costDashboard?: VoiceCostDashboardRenderer;
+    liveCallViewer?: VoiceLiveCallViewerRenderer;
+    replayTimeline?: VoiceReplayTimelineRenderer;
+};
+export type ResolvedVoiceDashboardRenderers = Required<VoiceDashboardHTMXRendererConfig>;
+export declare const resolveVoiceDashboardRenderers: (custom?: VoiceDashboardHTMXRendererConfig) => ResolvedVoiceDashboardRenderers;
+export declare const renderVoiceCostDashboardHTMX: (input: VoiceCostDashboardHTMXInput & {
+    custom?: VoiceCostDashboardRenderer;
+}) => string;
+export declare const renderVoiceReplayTimelineHTMX: (input: VoiceReplayTimelineHTMXInput & {
+    custom?: VoiceReplayTimelineRenderer;
+}) => string;
+export declare const renderVoiceLiveCallViewerHTMX: (input: VoiceLiveCallViewerHTMXInput & {
+    custom?: VoiceLiveCallViewerRenderer;
+}) => string;
+export declare const renderVoiceCostDashboardFromEvents: (input: {
+    attributes?: VoiceDashboardHTMXAttributes;
+    currency?: string;
+    events: ReadonlyArray<StoredVoiceTraceEvent>;
+    options?: Omit<VoiceCostDashboardOptions, "events">;
+    renderer?: VoiceCostDashboardRenderer;
+    title?: string;
+}) => string;
+export declare const renderVoiceReplayTimelineFromArtifact: (input: {
+    artifact: VoiceCallReviewArtifact;
+    attributes?: VoiceDashboardHTMXAttributes;
+    renderer?: VoiceReplayTimelineRenderer;
+    title?: string;
+}) => string;
+export declare const renderVoiceLiveCallViewerFromViewer: (input: {
+    attributes?: VoiceDashboardHTMXAttributes;
+    renderer?: VoiceLiveCallViewerRenderer;
+    title?: string;
+    viewer: LiveCallViewer;
+}) => string;
+export declare const renderVoiceLiveCallViewerFromState: (input: {
+    attributes?: VoiceDashboardHTMXAttributes;
+    renderer?: VoiceLiveCallViewerRenderer;
+    state: LiveCallViewState;
+    title?: string;
+}) => string;
+export declare const createLiveCallViewerFromOptions: (options: import("./liveCallViewer").CreateLiveCallViewerOptions) => LiveCallViewer;

package/dist/htmxDashboardRoutes.d.ts

@@ -0,0 +1,249 @@
+import { Elysia } from "elysia";
+import type { StoredVoiceTraceEvent, VoiceTraceEventStore } from "./trace";
+import type { StoredVoiceCallReviewArtifact, VoiceCallReviewStore } from "./testing/review";
+import type { LiveCallViewer } from "./client/liveCallViewer";
+import { type VoiceDashboardHTMXRendererConfig } from "./client/htmxDashboardRenderers";
+import type { VoiceCostDashboardOptions } from "./client/costDashboard";
+export type VoiceHTMXDashboardRoutesShared = {
+    name?: string;
+    render?: VoiceDashboardHTMXRendererConfig;
+};
+export type VoiceHTMXCostDashboardRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    bucketBy?: VoiceCostDashboardOptions["bucketBy"];
+    currency?: string;
+    fromMs?: () => number | undefined;
+    path?: string;
+    pollIntervalMs?: number;
+    resolveEvents: () => Promise<ReadonlyArray<StoredVoiceTraceEvent>> | ReadonlyArray<StoredVoiceTraceEvent>;
+    title?: string;
+    toMs?: () => number | undefined;
+};
+export declare const createVoiceCostDashboardHTMXRoute: (options: VoiceHTMXCostDashboardRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        get: {
+            body: unknown;
+            params: {};
+            query: unknown;
+            headers: unknown;
+            response: {
+                200: Response;
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceHTMXReplayTimelineRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    /** The HTML route mounts at `${path}/:artifactId`. */
+    path?: string;
+    resolveArtifact: (artifactId: string) => Promise<StoredVoiceCallReviewArtifact | undefined> | StoredVoiceCallReviewArtifact | undefined;
+    title?: string;
+};
+export declare const createVoiceReplayTimelineHTMXRoute: (options: VoiceHTMXReplayTimelineRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        ":artifactId": {
+            get: {
+                body: unknown;
+                params: {
+                    artifactId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceHTMXLiveCallViewerRoutesOptions = VoiceHTMXDashboardRoutesShared & {
+    /** Route mounts at `${path}/:sessionId`. */
+    path?: string;
+    pollIntervalMs?: number;
+    resolveViewer: (sessionId: string) => Promise<LiveCallViewer | undefined> | LiveCallViewer | undefined;
+    title?: string;
+};
+export declare const createVoiceLiveCallViewerHTMXRoute: (options: VoiceHTMXLiveCallViewerRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {
+    [x: string]: {
+        ":sessionId": {
+            get: {
+                body: unknown;
+                params: {
+                    sessionId: string;
+                } & {};
+                query: unknown;
+                headers: unknown;
+                response: {
+                    200: Response;
+                    422: {
+                        type: "validation";
+                        on: string;
+                        summary?: string;
+                        message?: string;
+                        found?: unknown;
+                        property?: string;
+                        expected?: string;
+                    };
+                };
+            };
+        };
+    };
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type VoiceHTMXDashboardRoutesOptions = {
+    cost?: Omit<VoiceHTMXCostDashboardRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+    liveCall?: Omit<VoiceHTMXLiveCallViewerRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+    name?: string;
+    render?: VoiceDashboardHTMXRendererConfig;
+    replay?: Omit<VoiceHTMXReplayTimelineRoutesOptions, keyof VoiceHTMXDashboardRoutesShared>;
+};
+export declare const createVoiceHTMXDashboardRoutes: (options: VoiceHTMXDashboardRoutesOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;
+export type CreateVoiceHTMXDashboardRoutesFromStoresOptions = {
+    liveViewerByCallId?: (sessionId: string) => Promise<LiveCallViewer | undefined> | LiveCallViewer | undefined;
+    pollIntervalMs?: number;
+    render?: VoiceDashboardHTMXRendererConfig;
+    reviewStore?: VoiceCallReviewStore;
+    traceStore?: VoiceTraceEventStore;
+};
+export declare const createVoiceHTMXDashboardRoutesFromStores: (options: CreateVoiceHTMXDashboardRoutesFromStoresOptions) => Elysia<"", {
+    decorator: {};
+    store: {};
+    derive: {};
+    resolve: {};
+}, {
+    typebox: {};
+    error: {};
+}, {
+    schema: {};
+    standaloneSchema: {};
+    macro: {};
+    macroFn: {};
+    parser: {};
+    response: {};
+}, {}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}, {
+    derive: {};
+    resolve: {};
+    schema: {};
+    standaloneSchema: {};
+    response: {};
+}>;

package/dist/svelte/createVoiceCostDashboard.d.ts

@@ -0,0 +1,13 @@
+import { type VoiceCostDashboardOptions, type VoiceCostDashboardReport } from "../client/costDashboard";
+export type CreateVoiceCostDashboardOptions = VoiceCostDashboardOptions & {
+    currency?: string;
+    title?: string;
+};
+export declare const renderVoiceCostDashboardHTML: (report: VoiceCostDashboardReport, options?: {
+    currency?: string;
+    title?: string;
+}) => string;
+export declare const createVoiceCostDashboard: (options: CreateVoiceCostDashboardOptions) => {
+    getHTML: () => string;
+    getReport: () => VoiceCostDashboardReport;
+};

package/dist/svelte/createVoiceLiveCallViewer.d.ts

@@ -0,0 +1,26 @@
+import { type CreateLiveCallViewerOptions, type LiveCallViewState } from "../client/liveCallViewer";
+export declare const renderVoiceLiveCallViewerHTML: (state: LiveCallViewState, options?: {
+    title?: string;
+}) => string;
+export type CreateVoiceLiveCallViewerSvelteOptions = CreateLiveCallViewerOptions & {
+    title?: string;
+};
+export declare const createVoiceLiveCallViewer: (options: CreateVoiceLiveCallViewerSvelteOptions) => {
+    getHTML: () => string;
+    title: string | undefined;
+    applyControl: (control: {
+        reason?: string;
+        type: string;
+    }) => void;
+    applyEvent: (event: import("..").LiveCallTimelineEvent) => void;
+    applyMonitorEvent: (event: {
+        payload: Record<string, unknown>;
+        type: string;
+    }) => void;
+    getState: () => LiveCallViewState;
+    noteAgentAudio: (at?: number) => void;
+    notePartial: (text: string, at?: number) => void;
+    noteTranscript: (text: string, at?: number) => void;
+    reset: (sessionId: string, startedAt?: number) => void;
+    subscribe: (subscriber: () => void) => () => void;
+};

package/dist/svelte/createVoiceReplayTimeline.d.ts

@@ -0,0 +1,13 @@
+import type { VoiceCallReviewArtifact } from "../testing/review";
+import { type ReplayTimelineReport } from "../client/replayTimeline";
+export declare const renderVoiceReplayTimelineHTML: (report: ReplayTimelineReport, options?: {
+    title?: string;
+}) => string;
+export type CreateVoiceReplayTimelineOptions = {
+    artifact: VoiceCallReviewArtifact;
+    title?: string;
+};
+export declare const createVoiceReplayTimeline: (options: CreateVoiceReplayTimelineOptions) => {
+    getHTML: () => string;
+    getReport: () => ReplayTimelineReport;
+};

package/dist/svelte/index.d.ts

@@ -1,6 +1,12 @@
 export { createVoiceCampaignDialerProof } from "./createVoiceCampaignDialerProof";
 export { createVoiceWidget } from "./createVoiceWidget";
 export type { CreateVoiceWidgetOptions, VoiceWidgetLabels, VoiceWidgetTheme, VoiceWidgetViewModel, } from "./createVoiceWidget";
+export { createVoiceCostDashboard, renderVoiceCostDashboardHTML, } from "./createVoiceCostDashboard";
+export type { CreateVoiceCostDashboardOptions } from "./createVoiceCostDashboard";
+export { createVoiceLiveCallViewer, renderVoiceLiveCallViewerHTML, } from "./createVoiceLiveCallViewer";
+export type { CreateVoiceLiveCallViewerSvelteOptions } from "./createVoiceLiveCallViewer";
+export { createVoiceReplayTimeline, renderVoiceReplayTimelineHTML, } from "./createVoiceReplayTimeline";
+export type { CreateVoiceReplayTimelineOptions } from "./createVoiceReplayTimeline";
 export { createVoiceDeliveryRuntime } from "./createVoiceDeliveryRuntime";
 export { createVoiceOpsActionCenter } from "./createVoiceOpsActionCenter";
 export { createVoiceLiveOps } from "./createVoiceLiveOps";