@pinecall/protocol 0.1.0

package/dist/generated/rest.d.ts

@@ -0,0 +1,1031 @@
+import { z } from "zod";
+/** GET /v1/calls/{call}/state: the whole log folded, and the seq a stream resumes from. */
+export declare const CallStateSchema: z.ZodObject<{
+    state: z.ZodObject<{
+        seq: z.ZodInt;
+        agent: z.ZodString;
+        call: z.ZodNullable<z.ZodString>;
+        status: z.ZodEnum<{
+            idle: "idle";
+            ringing: "ringing";
+            dialing: "dialing";
+            active: "active";
+            ended: "ended";
+        }>;
+        channel: z.ZodNullable<z.ZodEnum<{
+            phone: "phone";
+            web: "web";
+            whatsapp: "whatsapp";
+        }>>;
+        direction: z.ZodNullable<z.ZodEnum<{
+            inbound: "inbound";
+            outbound: "outbound";
+        }>>;
+        from: z.ZodNullable<z.ZodString>;
+        to: z.ZodNullable<z.ZodString>;
+        caller: z.ZodNullable<z.ZodObject<{
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        room: z.ZodNullable<z.ZodObject<{
+            name: z.ZodString;
+            sid: z.ZodString;
+            participants: z.ZodArray<z.ZodObject<{
+                identity: z.ZodString;
+                kind: z.ZodEnum<{
+                    agent: "agent";
+                    caller: "caller";
+                    supervisor: "supervisor";
+                    listener: "listener";
+                    sip: "sip";
+                }>;
+                name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                joined_at: z.ZodNumber;
+                speaking: z.ZodBoolean;
+                attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.core.$strict>>;
+            caller: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>;
+        started_at: z.ZodNullable<z.ZodNumber>;
+        ended_at: z.ZodNullable<z.ZodNumber>;
+        end_reason: z.ZodNullable<z.ZodEnum<{
+            caller_hung_up: "caller_hung_up";
+            agent_hung_up: "agent_hung_up";
+            supervisor_ended: "supervisor_ended";
+            transferred: "transferred";
+            no_answer: "no_answer";
+            busy: "busy";
+            dial_failed: "dial_failed";
+            timeout: "timeout";
+            drained: "drained";
+            app_detached: "app_detached";
+            error: "error";
+        }>>;
+        outcome: z.ZodNullable<z.ZodString>;
+        user_state: z.ZodNullable<z.ZodEnum<{
+            listening: "listening";
+            speaking: "speaking";
+            away: "away";
+        }>>;
+        agent_state: z.ZodNullable<z.ZodEnum<{
+            listening: "listening";
+            speaking: "speaking";
+            initializing: "initializing";
+            idle: "idle";
+            thinking: "thinking";
+        }>>;
+        live: z.ZodObject<{
+            user: z.ZodNullable<z.ZodString>;
+            agent: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>;
+        turns: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            role: z.ZodLiteral<"user">;
+            speech_id: z.ZodString;
+            item_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            text: z.ZodString;
+            language: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            transcript_confidence: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            metrics: z.ZodObject<{
+                started_speaking_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                stopped_speaking_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                transcription_delay: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                end_of_turn_delay: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                on_user_turn_completed_delay: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                stt_metadata: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>, z.ZodObject<{
+            role: z.ZodLiteral<"agent">;
+            speech_id: z.ZodString;
+            item_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            text: z.ZodString;
+            interrupted: z.ZodBoolean;
+            metrics: z.ZodObject<{
+                started_speaking_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                stopped_speaking_at: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                llm_node_ttft: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                llm_node_tps: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                llm_node_ttfs: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                tts_node_ttfb: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                playback_latency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                e2e_latency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                provider_request_ids: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                llm_metadata: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>>;
+                tts_metadata: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                }, z.core.$strict>>>;
+            }, z.core.$strict>;
+        }, z.core.$strict>], "role">>;
+        metrics: z.ZodObject<{
+            llm: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"llm_metrics">;
+                label: z.ZodString;
+                request_id: z.ZodString;
+                timestamp: z.ZodNumber;
+                duration: z.ZodNumber;
+                ttft: z.ZodNumber;
+                cancelled: z.ZodBoolean;
+                completion_tokens: z.ZodInt;
+                prompt_tokens: z.ZodInt;
+                prompt_cached_tokens: z.ZodInt;
+                cache_creation_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                reasoning_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                total_tokens: z.ZodInt;
+                tokens_per_second: z.ZodNumber;
+                speech_id: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            stt: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"stt_metrics">;
+                label: z.ZodString;
+                request_id: z.ZodString;
+                timestamp: z.ZodNumber;
+                duration: z.ZodNumber;
+                audio_duration: z.ZodNumber;
+                input_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                output_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                streamed: z.ZodBoolean;
+                acquire_time: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                connection_reused: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            tts: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"tts_metrics">;
+                label: z.ZodString;
+                request_id: z.ZodString;
+                timestamp: z.ZodNumber;
+                ttfb: z.ZodNumber;
+                duration: z.ZodNumber;
+                audio_duration: z.ZodNumber;
+                cancelled: z.ZodBoolean;
+                characters_count: z.ZodInt;
+                input_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                output_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                streamed: z.ZodBoolean;
+                acquire_time: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                connection_reused: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                segment_id: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                speech_id: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            vad: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"vad_metrics">;
+                label: z.ZodString;
+                timestamp: z.ZodNumber;
+                idle_time: z.ZodNumber;
+                inference_duration_total: z.ZodNumber;
+                inference_count: z.ZodInt;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            eou: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"eou_metrics">;
+                timestamp: z.ZodNumber;
+                end_of_utterance_delay: z.ZodNumber;
+                transcription_delay: z.ZodNumber;
+                on_user_turn_completed_delay: z.ZodNumber;
+                speech_id: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            eot: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"eot_inference_metrics">;
+                timestamp: z.ZodNumber;
+                total_duration: z.ZodNumber;
+                detection_delay: z.ZodNumber;
+                prediction_duration: z.ZodNumber;
+                num_requests: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            interruption: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"interruption_metrics">;
+                timestamp: z.ZodNumber;
+                total_duration: z.ZodNumber;
+                prediction_duration: z.ZodNumber;
+                detection_delay: z.ZodNumber;
+                num_interruptions: z.ZodInt;
+                num_backchannels: z.ZodInt;
+                num_requests: z.ZodInt;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            realtime: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"realtime_model_metrics">;
+                label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                request_id: z.ZodString;
+                timestamp: z.ZodNumber;
+                duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                session_duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                ttft: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                cancelled: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                input_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                output_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                total_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                tokens_per_second: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                input_token_details: z.ZodObject<{
+                    audio_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    text_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    image_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    cached_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    cached_tokens_details: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                        audio_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                        text_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                        image_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    }, z.core.$strict>>>>;
+                }, z.core.$strict>;
+                output_token_details: z.ZodObject<{
+                    text_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    audio_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                    image_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                }, z.core.$strict>;
+                acquire_time: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                connection_reused: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+            avatar: z.ZodArray<z.ZodObject<{
+                type: z.ZodLiteral<"avatar_metrics">;
+                timestamp: z.ZodNumber;
+                playback_latency: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                session_started_time: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodNumber>>>;
+                avatar_joined_time: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodNumber>>>;
+                metadata: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodObject<{
+                    model_name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                    model_provider: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+                }, z.core.$strict>>>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        tools: z.ZodArray<z.ZodObject<{
+            call_id: z.ZodString;
+            name: z.ZodString;
+            arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            status: z.ZodEnum<{
+                running: "running";
+                done: "done";
+                failed: "failed";
+            }>;
+            output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
+            error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            summary: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            duration_s: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            seq: z.ZodInt;
+        }, z.core.$strict>>;
+        app_state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        events: z.ZodArray<z.ZodObject<{
+            seq: z.ZodInt;
+            name: z.ZodString;
+            source: z.ZodEnum<{
+                app: "app";
+                participant: "participant";
+            }>;
+            identity: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        prompt: z.ZodRecord<z.ZodString, z.ZodObject<{
+            hash: z.ZodString;
+            chars: z.ZodInt;
+            seq: z.ZodInt;
+        }, z.core.$strict>>;
+        tools_visible: z.ZodArray<z.ZodString>;
+        confirms: z.ZodArray<z.ZodObject<{
+            tool: z.ZodString;
+            call_id: z.ZodString;
+            audience: z.ZodString;
+            phrase: z.ZodString;
+            status: z.ZodEnum<{
+                pending: "pending";
+                granted: "granted";
+                declined: "declined";
+            }>;
+            said: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        memory: z.ZodArray<z.ZodObject<{
+            op: z.ZodEnum<{
+                recall: "recall";
+                remember: "remember";
+                forget: "forget";
+            }>;
+            contact: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            query: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            facts: z.ZodArray<z.ZodObject<{
+                id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                text: z.ZodString;
+                category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+                source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+            took_ms: z.ZodNumber;
+        }, z.core.$strict>>;
+        sources: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            path: z.ZodString;
+            heading: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            score: z.ZodNumber;
+            excerpt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        handoff: z.ZodObject<{
+            active: z.ZodBoolean;
+            by: z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        held: z.ZodBoolean;
+        muted: z.ZodBoolean;
+        transfer: z.ZodNullable<z.ZodObject<{
+            to: z.ZodString;
+            mode: z.ZodEnum<{
+                cold: "cold";
+                warm: "warm";
+            }>;
+            status: z.ZodEnum<{
+                done: "done";
+                failed: "failed";
+                requested: "requested";
+            }>;
+            by: z.ZodEnum<{
+                agent: "agent";
+                supervisor: "supervisor";
+            }>;
+        }, z.core.$strict>>;
+        usage: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            type: z.ZodLiteral<"llm_usage">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            input_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_cached_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_cache_creation_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_audio_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_cached_audio_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_text_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_cached_text_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_image_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            input_cached_image_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            output_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            output_audio_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            output_text_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            output_reasoning_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            session_duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"tts_usage">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            input_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            output_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            characters_count: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            audio_duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"stt_usage">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            input_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            output_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            audio_duration: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"interruption_usage">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            total_requests: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        }, z.core.$strict>, z.ZodObject<{
+            type: z.ZodLiteral<"eot_usage">;
+            provider: z.ZodString;
+            model: z.ZodString;
+            total_requests: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        }, z.core.$strict>], "type">>;
+        cost: z.ZodNullable<z.ZodObject<{
+            eur: z.ZodNumber;
+            rate: z.ZodObject<{
+                currency: z.ZodLiteral<"EUR">;
+                usd_to_eur: z.ZodNumber;
+                as_of: z.ZodString;
+            }, z.core.$strict>;
+            rows: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+                unit: z.ZodEnum<{
+                    input_tokens: "input_tokens";
+                    cached_input_tokens: "cached_input_tokens";
+                    cache_creation_tokens: "cache_creation_tokens";
+                    output_tokens: "output_tokens";
+                    characters: "characters";
+                    audio_seconds: "audio_seconds";
+                    requests: "requests";
+                    session_seconds: "session_seconds";
+                }>;
+                quantity: z.ZodNumber;
+                unit_price_usd: z.ZodNumber;
+                eur: z.ZodNumber;
+            }, z.core.$strict>>;
+            unpriced: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        routes: z.ZodArray<z.ZodObject<{
+            channel: z.ZodEnum<{
+                phone: "phone";
+                web: "web";
+                whatsapp: "whatsapp";
+            }>;
+            number: z.ZodNullable<z.ZodString>;
+            label: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        gaps: z.ZodArray<z.ZodObject<{
+            from_seq: z.ZodInt;
+            to_seq: z.ZodInt;
+        }, z.core.$strict>>;
+        errors: z.ZodArray<z.ZodObject<{
+            seq: z.ZodInt;
+            code: z.ZodString;
+            message: z.ZodString;
+        }, z.core.$strict>>;
+        custom: z.ZodArray<z.ZodObject<{
+            seq: z.ZodInt;
+            name: z.ZodString;
+            data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    last_seq: z.ZodInt;
+    live: z.ZodBoolean;
+}, z.core.$strict>;
+export type CallState = z.infer<typeof CallStateSchema>;
+/** One page of a log: what this reader may see, whether the log is open, and where to resume. */
+export declare const LogPageSchema: z.ZodObject<{
+    entries: z.ZodArray<z.ZodObject<{
+        seq: z.ZodInt;
+        ts: z.ZodNumber;
+        call: z.ZodNullable<z.ZodString>;
+        agent: z.ZodString;
+        type: z.ZodString;
+        ephemeral: z.ZodBoolean;
+        data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, z.core.$strict>>;
+    live: z.ZodBoolean;
+    next: z.ZodNullable<z.ZodInt>;
+}, z.core.$strict>;
+export type LogPage = z.infer<typeof LogPageSchema>;
+/** One call as a list draws it: which call, how far the log got, and the state's own fields. */
+export declare const SessionLineSchema: z.ZodObject<{
+    call: z.ZodString;
+    agent: z.ZodString;
+    live: z.ZodBoolean;
+    last_seq: z.ZodInt;
+    status: z.ZodEnum<{
+        idle: "idle";
+        ringing: "ringing";
+        dialing: "dialing";
+        active: "active";
+        ended: "ended";
+    }>;
+    channel: z.ZodNullable<z.ZodEnum<{
+        phone: "phone";
+        web: "web";
+        whatsapp: "whatsapp";
+    }>>;
+    direction: z.ZodNullable<z.ZodEnum<{
+        inbound: "inbound";
+        outbound: "outbound";
+    }>>;
+    from: z.ZodNullable<z.ZodString>;
+    to: z.ZodNullable<z.ZodString>;
+    caller: z.ZodNullable<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>;
+    started_at: z.ZodNullable<z.ZodNumber>;
+    ended_at: z.ZodNullable<z.ZodNumber>;
+    end_reason: z.ZodNullable<z.ZodEnum<{
+        caller_hung_up: "caller_hung_up";
+        agent_hung_up: "agent_hung_up";
+        supervisor_ended: "supervisor_ended";
+        transferred: "transferred";
+        no_answer: "no_answer";
+        busy: "busy";
+        dial_failed: "dial_failed";
+        timeout: "timeout";
+        drained: "drained";
+        app_detached: "app_detached";
+        error: "error";
+    }>>;
+    outcome: z.ZodNullable<z.ZodString>;
+    cost: z.ZodNullable<z.ZodObject<{
+        eur: z.ZodNumber;
+        rate: z.ZodObject<{
+            currency: z.ZodLiteral<"EUR">;
+            usd_to_eur: z.ZodNumber;
+            as_of: z.ZodString;
+        }, z.core.$strict>;
+        rows: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+            unit: z.ZodEnum<{
+                input_tokens: "input_tokens";
+                cached_input_tokens: "cached_input_tokens";
+                cache_creation_tokens: "cache_creation_tokens";
+                output_tokens: "output_tokens";
+                characters: "characters";
+                audio_seconds: "audio_seconds";
+                requests: "requests";
+                session_seconds: "session_seconds";
+            }>;
+            quantity: z.ZodNumber;
+            unit_price_usd: z.ZodNumber;
+            eur: z.ZodNumber;
+        }, z.core.$strict>>;
+        unpriced: z.ZodArray<z.ZodObject<{
+            provider: z.ZodString;
+            model: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SessionLine = z.infer<typeof SessionLineSchema>;
+/** GET /v1/agents/{slug}/sessions: which calls that agent handled, newest first. */
+export declare const SessionListSchema: z.ZodObject<{
+    calls: z.ZodArray<z.ZodObject<{
+        call: z.ZodString;
+        agent: z.ZodString;
+        live: z.ZodBoolean;
+        last_seq: z.ZodInt;
+        status: z.ZodEnum<{
+            idle: "idle";
+            ringing: "ringing";
+            dialing: "dialing";
+            active: "active";
+            ended: "ended";
+        }>;
+        channel: z.ZodNullable<z.ZodEnum<{
+            phone: "phone";
+            web: "web";
+            whatsapp: "whatsapp";
+        }>>;
+        direction: z.ZodNullable<z.ZodEnum<{
+            inbound: "inbound";
+            outbound: "outbound";
+        }>>;
+        from: z.ZodNullable<z.ZodString>;
+        to: z.ZodNullable<z.ZodString>;
+        caller: z.ZodNullable<z.ZodObject<{
+            id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            phone: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            email: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            external_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>;
+        started_at: z.ZodNullable<z.ZodNumber>;
+        ended_at: z.ZodNullable<z.ZodNumber>;
+        end_reason: z.ZodNullable<z.ZodEnum<{
+            caller_hung_up: "caller_hung_up";
+            agent_hung_up: "agent_hung_up";
+            supervisor_ended: "supervisor_ended";
+            transferred: "transferred";
+            no_answer: "no_answer";
+            busy: "busy";
+            dial_failed: "dial_failed";
+            timeout: "timeout";
+            drained: "drained";
+            app_detached: "app_detached";
+            error: "error";
+        }>>;
+        outcome: z.ZodNullable<z.ZodString>;
+        cost: z.ZodNullable<z.ZodObject<{
+            eur: z.ZodNumber;
+            rate: z.ZodObject<{
+                currency: z.ZodLiteral<"EUR">;
+                usd_to_eur: z.ZodNumber;
+                as_of: z.ZodString;
+            }, z.core.$strict>;
+            rows: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+                unit: z.ZodEnum<{
+                    input_tokens: "input_tokens";
+                    cached_input_tokens: "cached_input_tokens";
+                    cache_creation_tokens: "cache_creation_tokens";
+                    output_tokens: "output_tokens";
+                    characters: "characters";
+                    audio_seconds: "audio_seconds";
+                    requests: "requests";
+                    session_seconds: "session_seconds";
+                }>;
+                quantity: z.ZodNumber;
+                unit_price_usd: z.ZodNumber;
+                eur: z.ZodNumber;
+            }, z.core.$strict>>;
+            unpriced: z.ZodArray<z.ZodObject<{
+                provider: z.ZodString;
+                model: z.ZodString;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SessionList = z.infer<typeof SessionListSchema>;
+/** One corner of a world holding an agent: the member whose it is, named so a person can read it. */
+export declare const LineHolderSchema: z.ZodObject<{
+    holder: z.ZodNullable<z.ZodString>;
+    name: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type LineHolder = z.infer<typeof LineHolderSchema>;
+/** One agent, as somebody choosing which to open needs to see it: its name and its channels. */
+export declare const HeldAgentSchema: z.ZodObject<{
+    slug: z.ZodString;
+    channels: z.ZodArray<z.ZodEnum<{
+        phone: "phone";
+        web: "web";
+        whatsapp: "whatsapp";
+    }>>;
+    holder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        holder: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type HeldAgent = z.infer<typeof HeldAgentSchema>;
+/** GET /v1/agents: every agent this fleet is holding right now, as the front page lists them. */
+export declare const AgentListSchema: z.ZodObject<{
+    agents: z.ZodArray<z.ZodObject<{
+        slug: z.ZodString;
+        channels: z.ZodArray<z.ZodEnum<{
+            phone: "phone";
+            web: "web";
+            whatsapp: "whatsapp";
+        }>>;
+        holder: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            holder: z.ZodNullable<z.ZodString>;
+            name: z.ZodNullable<z.ZodString>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type AgentList = z.infer<typeof AgentListSchema>;
+/**
+ * GET /v1/agents/{slug}/line: whose terminal a call that RINGS at this agent's doors lands in. An
+ * org shares one sandbox number, so it rings in one place and which one is claimed.
+ */
+export declare const TheLineSchema: z.ZodObject<{
+    agent: z.ZodString;
+    env: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    held: z.ZodBoolean;
+    holding: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        holder: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>>;
+    yours: z.ZodBoolean;
+    waiting: z.ZodArray<z.ZodObject<{
+        holder: z.ZodNullable<z.ZodString>;
+        name: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+    calling: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TheLine = z.infer<typeof TheLineSchema>;
+/**
+ * PUT /v1/knowledge/{base}, the body: the tenant's folder as of now, sent whole. The base is
+ * replaced, never merged.
+ */
+export declare const KnowledgePushSchema: z.ZodObject<{
+    files: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgePush = z.infer<typeof KnowledgePushSchema>;
+/**
+ * One question of a base's golden: what somebody asks, and the chunk that should answer it. A
+ * chunk answers when its file and heading path start with `expects`, so naming a file alone
+ * accepts any chunk of it and naming a heading accepts that section.
+ */
+export declare const GoldenQuestionSchema: z.ZodObject<{
+    asks: z.ZodString;
+    expects: z.ZodString;
+}, z.core.$strict>;
+export type GoldenQuestion = z.infer<typeof GoldenQuestionSchema>;
+/**
+ * POST /v1/knowledge/{base}/eval, the body: the questions a base is held to. A golden is fixed and
+ * the index is the variable; a question is never softened so a change can pass.
+ */
+export declare const KnowledgeGoldenSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        asks: z.ZodString;
+        expects: z.ZodString;
+    }, z.core.$strict>>;
+    k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+}, z.core.$strict>;
+export type KnowledgeGolden = z.infer<typeof KnowledgeGoldenSchema>;
+/** One question whose expected chunk was not among the k returned, and what came back instead. */
+export declare const GoldenMissSchema: z.ZodObject<{
+    asks: z.ZodString;
+    expects: z.ZodString;
+    found: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type GoldenMiss = z.infer<typeof GoldenMissSchema>;
+/**
+ * POST /v1/knowledge/{base}/eval, the answer: how the index did on its own golden. Both figures
+ * are computed by code, with no model, so two runs of the same golden over the same base answer
+ * the same numbers.
+ */
+export declare const KnowledgeScoreSchema: z.ZodObject<{
+    base: z.ZodString;
+    model: z.ZodString;
+    questions: z.ZodInt;
+    k: z.ZodInt;
+    recall_at_k: z.ZodNumber;
+    ndcg_at_10: z.ZodNumber;
+    took_ms: z.ZodNumber;
+    misses: z.ZodArray<z.ZodObject<{
+        asks: z.ZodString;
+        expects: z.ZodString;
+        found: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgeScore = z.infer<typeof KnowledgeScoreSchema>;
+/**
+ * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, and how long that
+ * took.
+ */
+export declare const KnowledgePushedSchema: z.ZodObject<{
+    base: z.ZodString;
+    chunks: z.ZodInt;
+    took_ms: z.ZodNumber;
+}, z.core.$strict>;
+export type KnowledgePushed = z.infer<typeof KnowledgePushedSchema>;
+/** One knowledge base as the list draws it: its name, its size, and when it was last pushed. */
+export declare const KnowledgeBaseSchema: z.ZodObject<{
+    base: z.ZodString;
+    chunks: z.ZodInt;
+    model: z.ZodString;
+    pushed_at: z.ZodNumber;
+}, z.core.$strict>;
+export type KnowledgeBase = z.infer<typeof KnowledgeBaseSchema>;
+/** GET /v1/knowledge: every base this org has pushed. */
+export declare const KnowledgeListSchema: z.ZodObject<{
+    bases: z.ZodArray<z.ZodObject<{
+        base: z.ZodString;
+        chunks: z.ZodInt;
+        model: z.ZodString;
+        pushed_at: z.ZodNumber;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgeList = z.infer<typeof KnowledgeListSchema>;
+/**
+ * One fact of a contact's history: a MemoryFact with the two dates that bound it. A fact is never
+ * deleted, only superseded, so the history keeps every version.
+ */
+export declare const ContactFactSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    text: z.ZodString;
+    category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    valid_from: z.ZodNumber;
+    invalidated_at: z.ZodNullable<z.ZodNumber>;
+}, z.core.$strict>;
+export type ContactFact = z.infer<typeof ContactFactSchema>;
+/**
+ * GET /v1/contacts/{contact}/memory: everything memory ever kept about one contact, current facts
+ * first.
+ */
+export declare const ContactMemorySchema: z.ZodObject<{
+    facts: z.ZodArray<z.ZodObject<{
+        id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        text: z.ZodString;
+        category: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        source: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        valid_from: z.ZodNumber;
+        invalidated_at: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ContactMemory = z.infer<typeof ContactMemorySchema>;
+/**
+ * DELETE /v1/contacts/{contact}/memory, the answer: how many facts the right to be forgotten
+ * erased.
+ */
+export declare const ForgottenSchema: z.ZodObject<{
+    forgotten: z.ZodInt;
+}, z.core.$strict>;
+export type Forgotten = z.infer<typeof ForgottenSchema>;
+/**
+ * One question of a memory golden: what memory holds about the contact who asks it, the words they
+ * just said, and the fact or facts that should come back. The facts are the question's own, so a
+ * golden needs no contact in any table.
+ */
+export declare const MemoryQuestionSchema: z.ZodObject<{
+    holds: z.ZodArray<z.ZodString>;
+    asks: z.ZodString;
+    expects: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type MemoryQuestion = z.infer<typeof MemoryQuestionSchema>;
+/**
+ * POST /v1/contacts/memory/eval, the body: the questions memory is held to. Each question brings
+ * its own facts, which are written to a scratch contact of this org, asked, and deleted. A golden
+ * is fixed and the ranking is the variable; a question is never softened so a change can pass.
+ */
+export declare const MemoryGoldenSchema: z.ZodObject<{
+    questions: z.ZodArray<z.ZodObject<{
+        holds: z.ZodArray<z.ZodString>;
+        asks: z.ZodString;
+        expects: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+}, z.core.$strict>;
+export type MemoryGolden = z.infer<typeof MemoryGoldenSchema>;
+/**
+ * One question memory did not answer whole: what it wanted and did not get, and what came back
+ * instead. GoldenMiss is the knowledge base's and names the one chunk that should have won; a
+ * memory question may expect several facts and miss some of them.
+ */
+export declare const MemoryMissSchema: z.ZodObject<{
+    asks: z.ZodString;
+    missing: z.ZodArray<z.ZodString>;
+    found: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type MemoryMiss = z.infer<typeof MemoryMissSchema>;
+/**
+ * POST /v1/contacts/memory/eval, the answer: how memory ranked the facts its own golden asked for.
+ * Both figures are computed by code, with no model in the loop, so two runs of one golden answer
+ * the same numbers.
+ */
+export declare const MemoryScoreSchema: z.ZodObject<{
+    model: z.ZodString;
+    questions: z.ZodInt;
+    k: z.ZodInt;
+    recall_at_k: z.ZodNumber;
+    ndcg_at_10: z.ZodNumber;
+    took_ms: z.ZodNumber;
+    misses: z.ZodArray<z.ZodObject<{
+        asks: z.ZodString;
+        missing: z.ZodArray<z.ZodString>;
+        found: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type MemoryScore = z.infer<typeof MemoryScoreSchema>;
+/**
+ * What must come of one call's hang-up: each field is one of the four ways a hang-up costs a
+ * business. Nothing here compares one sentence to another — a category is the class's own word, a
+ * value is a literal the caller said out loud, and a supersession is an id — because two ways of
+ * writing one fact are one fact.
+ */
+export declare const ExtractionExpectedSchema: z.ZodObject<{
+    writes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    never: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    never_says: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    invalidates: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+}, z.core.$strict>;
+export type ExtractionExpected = z.infer<typeof ExtractionExpectedSchema>;
+/**
+ * One call written down and what memory must make of it: the write side of the table, judged by
+ * code. The read side is MemoryGolden and neither answers for the other — a call may extract the
+ * perfect fact and never see it again, because six is what a turn is handed and the seventh is
+ * cut.
+ */
+export declare const ExtractionGoldenSchema: z.ZodObject<{
+    name: z.ZodString;
+    said: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+    holds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    plants: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    channel: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        phone: "phone";
+        web: "web";
+        whatsapp: "whatsapp";
+    }>>>;
+    expect: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        writes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        never: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        never_says: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        invalidates: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
+export type ExtractionGolden = z.infer<typeof ExtractionGoldenSchema>;
+/**
+ * POST /v1/agents/{slug}/memory/extraction, the body: the goldens whole, as the tenant wrote them
+ * down. Each costs ONE model call — the very one a hang-up makes — run on the org's own model and
+ * keys against the class the caller is holding.
+ */
+export declare const ExtractionCasesSchema: z.ZodObject<{
+    cases: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        said: z.ZodArray<z.ZodTuple<[z.ZodString, z.ZodString], null>>;
+        holds: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        plants: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        channel: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            phone: "phone";
+            web: "web";
+            whatsapp: "whatsapp";
+        }>>>;
+        expect: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            writes: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            never: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            never_says: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            invalidates: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ExtractionCases = z.infer<typeof ExtractionCasesSchema>;
+/**
+ * One thing that did not hold about a case: which of the questions, and the evidence in a sentence
+ * a person can act on.
+ */
+export declare const ExtractionBrokeSchema: z.ZodObject<{
+    check: z.ZodString;
+    detail: z.ZodString;
+}, z.core.$strict>;
+export type ExtractionBroke = z.infer<typeof ExtractionBrokeSchema>;
+/** One case, run: what memory would have kept, what admission refused, and what did not hold. */
+export declare const ExtractionJudgedSchema: z.ZodObject<{
+    name: z.ZodString;
+    held: z.ZodBoolean;
+    wrote: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    refused: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    broke: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        check: z.ZodString;
+        detail: z.ZodString;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type ExtractionJudged = z.infer<typeof ExtractionJudgedSchema>;
+/**
+ * POST /v1/agents/{slug}/memory/extraction, the answer: which model answered, how many cases held,
+ * and every one of them. A verb prints this and a pipeline exits on it.
+ */
+export declare const ExtractionRunSchema: z.ZodObject<{
+    agent: z.ZodString;
+    model: z.ZodString;
+    cases: z.ZodInt;
+    held: z.ZodInt;
+    took_ms: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        held: z.ZodBoolean;
+        wrote: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        refused: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        broke: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            check: z.ZodString;
+            detail: z.ZodString;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type ExtractionRun = z.infer<typeof ExtractionRunSchema>;
+/**
+ * POST /v1/calls/{call}/lookup, the body: which platform tool to run for this turn, and what to
+ * run it with. Worker-only; the gateway runs it against its own stores and writes memory.ops or
+ * docs.sources on the call's log itself.
+ */
+export declare const LookupRequestSchema: z.ZodObject<{
+    tool: z.ZodEnum<{
+        recall: "recall";
+        search: "search";
+    }>;
+    input: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strict>;
+export type LookupRequest = z.infer<typeof LookupRequestSchema>;
+/**
+ * POST /v1/calls/{call}/lookup, the answer: what the tool found, and how long finding it took. The
+ * output is JSON-encoded into a tool_result block, which is where everything from outside the
+ * conversation goes and the only place it goes.
+ */
+export declare const LookupResultSchema: z.ZodObject<{
+    output: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    took_ms: z.ZodNumber;
+}, z.core.$strict>;
+export type LookupResult = z.infer<typeof LookupResultSchema>;
+/**
+ * POST /v1/calls/{call}/remember, the answer: what the call taught about the contact, counted.
+ * Worker-only; the body is empty, the gateway reads the turns off its own log and writes
+ * memory.ops itself.
+ */
+export declare const RememberedSchema: z.ZodObject<{
+    ops: z.ZodInt;
+    took_ms: z.ZodNumber;
+}, z.core.$strict>;
+export type Remembered = z.infer<typeof RememberedSchema>;