@pinecall/protocol 0.2.0 → 0.4.0

package/dist/generated/rest.d.ts

@@ -6,11 +6,11 @@ export declare const CallStateSchema: z.ZodObject<{
         agent: z.ZodString;
         call: z.ZodNullable<z.ZodString>;
         status: z.ZodEnum<{
-            idle: "idle";
-            ringing: "ringing";
-            dialing: "dialing";
             active: "active";
+            dialing: "dialing";
             ended: "ended";
+            idle: "idle";
+            ringing: "ringing";
         }>;
         channel: z.ZodNullable<z.ZodEnum<{
             phone: "phone";
@@ -38,9 +38,9 @@ export declare const CallStateSchema: z.ZodObject<{
                 kind: z.ZodEnum<{
                     agent: "agent";
                     caller: "caller";
-                    supervisor: "supervisor";
                     listener: "listener";
                     sip: "sip";
+                    supervisor: "supervisor";
                 }>;
                 name: z.ZodOptional<z.ZodNullable<z.ZodString>>;
                 joined_at: z.ZodNumber;
@@ -52,29 +52,29 @@ export declare const CallStateSchema: z.ZodObject<{
         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";
+            app_detached: "app_detached";
             busy: "busy";
+            caller_hung_up: "caller_hung_up";
             dial_failed: "dial_failed";
-            timeout: "timeout";
             drained: "drained";
-            app_detached: "app_detached";
             error: "error";
+            no_answer: "no_answer";
+            supervisor_ended: "supervisor_ended";
+            timeout: "timeout";
+            transferred: "transferred";
         }>>;
         outcome: z.ZodNullable<z.ZodString>;
         user_state: z.ZodNullable<z.ZodEnum<{
+            away: "away";
             listening: "listening";
             speaking: "speaking";
-            away: "away";
         }>>;
         agent_state: z.ZodNullable<z.ZodEnum<{
+            idle: "idle";
+            initializing: "initializing";
             listening: "listening";
             speaking: "speaking";
-            initializing: "initializing";
-            idle: "idle";
             thinking: "thinking";
         }>>;
         live: z.ZodObject<{
@@ -290,9 +290,9 @@ export declare const CallStateSchema: z.ZodObject<{
             arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
             speech_id: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             status: z.ZodEnum<{
-                running: "running";
                 done: "done";
                 failed: "failed";
+                running: "running";
             }>;
             output: z.ZodOptional<z.ZodNullable<z.ZodUnknown>>;
             error: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -322,18 +322,18 @@ export declare const CallStateSchema: z.ZodObject<{
             audience: z.ZodString;
             phrase: z.ZodString;
             status: z.ZodEnum<{
-                pending: "pending";
-                granted: "granted";
                 declined: "declined";
+                granted: "granted";
+                pending: "pending";
             }>;
             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<{
+                forget: "forget";
                 recall: "recall";
                 remember: "remember";
-                forget: "forget";
             }>;
             contact: z.ZodOptional<z.ZodNullable<z.ZodString>>;
             query: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -433,12 +433,12 @@ export declare const CallStateSchema: z.ZodObject<{
                 provider: z.ZodString;
                 model: z.ZodString;
                 unit: z.ZodEnum<{
-                    input_tokens: "input_tokens";
-                    cached_input_tokens: "cached_input_tokens";
+                    audio_seconds: "audio_seconds";
                     cache_creation_tokens: "cache_creation_tokens";
-                    output_tokens: "output_tokens";
+                    cached_input_tokens: "cached_input_tokens";
                     characters: "characters";
-                    audio_seconds: "audio_seconds";
+                    input_tokens: "input_tokens";
+                    output_tokens: "output_tokens";
                     requests: "requests";
                     session_seconds: "session_seconds";
                 }>;
@@ -511,9 +511,9 @@ export type SessionScore = z.infer<typeof SessionScoreSchema>;
  * committing the business to something no tool call records.
  */
 export declare const SessionFlagSchema: z.ZodEnum<{
-    promise: "promise";
     escalated: "escalated";
     low_score: "low_score";
+    promise: "promise";
 }>;
 export type SessionFlag = z.infer<typeof SessionFlagSchema>;
 /** One call as a list draws it: which call, how far the log got, and the state's own fields. */
@@ -523,11 +523,11 @@ export declare const SessionLineSchema: z.ZodObject<{
     live: z.ZodBoolean;
     last_seq: z.ZodInt;
     status: z.ZodEnum<{
-        idle: "idle";
-        ringing: "ringing";
-        dialing: "dialing";
         active: "active";
+        dialing: "dialing";
         ended: "ended";
+        idle: "idle";
+        ringing: "ringing";
     }>;
     channel: z.ZodNullable<z.ZodEnum<{
         phone: "phone";
@@ -550,17 +550,17 @@ export declare const SessionLineSchema: z.ZodObject<{
     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";
+        app_detached: "app_detached";
         busy: "busy";
+        caller_hung_up: "caller_hung_up";
         dial_failed: "dial_failed";
-        timeout: "timeout";
         drained: "drained";
-        app_detached: "app_detached";
         error: "error";
+        no_answer: "no_answer";
+        supervisor_ended: "supervisor_ended";
+        timeout: "timeout";
+        transferred: "transferred";
     }>>;
     outcome: z.ZodNullable<z.ZodString>;
     cost: z.ZodNullable<z.ZodObject<{
@@ -574,12 +574,12 @@ export declare const SessionLineSchema: z.ZodObject<{
             provider: z.ZodString;
             model: z.ZodString;
             unit: z.ZodEnum<{
-                input_tokens: "input_tokens";
-                cached_input_tokens: "cached_input_tokens";
+                audio_seconds: "audio_seconds";
                 cache_creation_tokens: "cache_creation_tokens";
-                output_tokens: "output_tokens";
+                cached_input_tokens: "cached_input_tokens";
                 characters: "characters";
-                audio_seconds: "audio_seconds";
+                input_tokens: "input_tokens";
+                output_tokens: "output_tokens";
                 requests: "requests";
                 session_seconds: "session_seconds";
             }>;
@@ -599,9 +599,9 @@ export declare const SessionLineSchema: z.ZodObject<{
         reason: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>>>>;
     flags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
-        promise: "promise";
         escalated: "escalated";
         low_score: "low_score";
+        promise: "promise";
     }>>>>;
 }, z.core.$strict>;
 export type SessionLine = z.infer<typeof SessionLineSchema>;
@@ -616,11 +616,11 @@ export declare const SessionListSchema: z.ZodObject<{
         live: z.ZodBoolean;
         last_seq: z.ZodInt;
         status: z.ZodEnum<{
-            idle: "idle";
-            ringing: "ringing";
-            dialing: "dialing";
             active: "active";
+            dialing: "dialing";
             ended: "ended";
+            idle: "idle";
+            ringing: "ringing";
         }>;
         channel: z.ZodNullable<z.ZodEnum<{
             phone: "phone";
@@ -643,17 +643,17 @@ export declare const SessionListSchema: z.ZodObject<{
         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";
+            app_detached: "app_detached";
             busy: "busy";
+            caller_hung_up: "caller_hung_up";
             dial_failed: "dial_failed";
-            timeout: "timeout";
             drained: "drained";
-            app_detached: "app_detached";
             error: "error";
+            no_answer: "no_answer";
+            supervisor_ended: "supervisor_ended";
+            timeout: "timeout";
+            transferred: "transferred";
         }>>;
         outcome: z.ZodNullable<z.ZodString>;
         cost: z.ZodNullable<z.ZodObject<{
@@ -667,12 +667,12 @@ export declare const SessionListSchema: z.ZodObject<{
                 provider: z.ZodString;
                 model: z.ZodString;
                 unit: z.ZodEnum<{
-                    input_tokens: "input_tokens";
-                    cached_input_tokens: "cached_input_tokens";
+                    audio_seconds: "audio_seconds";
                     cache_creation_tokens: "cache_creation_tokens";
-                    output_tokens: "output_tokens";
+                    cached_input_tokens: "cached_input_tokens";
                     characters: "characters";
-                    audio_seconds: "audio_seconds";
+                    input_tokens: "input_tokens";
+                    output_tokens: "output_tokens";
                     requests: "requests";
                     session_seconds: "session_seconds";
                 }>;
@@ -692,9 +692,9 @@ export declare const SessionListSchema: z.ZodObject<{
             reason: z.ZodNullable<z.ZodString>;
         }, z.core.$strict>>>>;
         flags: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
-            promise: "promise";
             escalated: "escalated";
             low_score: "low_score";
+            promise: "promise";
         }>>>>;
     }, z.core.$strict>>;
     total: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodInt>>>;
@@ -779,8 +779,8 @@ export type JudgingWanted = z.infer<typeof JudgingWantedSchema>;
  */
 export declare const ThreadKindSchema: z.ZodEnum<{
     call: "call";
-    out: "out";
     in: "in";
+    out: "out";
 }>;
 export type ThreadKind = z.infer<typeof ThreadKindSchema>;
 /** The newest thing on a contact's thread. */
@@ -789,8 +789,8 @@ export declare const ThreadLastSchema: z.ZodObject<{
     at: z.ZodNumber;
     kind: z.ZodEnum<{
         call: "call";
-        out: "out";
         in: "in";
+        out: "out";
     }>;
 }, z.core.$strict>;
 export type ThreadLast = z.infer<typeof ThreadLastSchema>;
@@ -808,8 +808,8 @@ export declare const ThreadLineSchema: z.ZodObject<{
         at: z.ZodNumber;
         kind: z.ZodEnum<{
             call: "call";
-            out: "out";
             in: "in";
+            out: "out";
         }>;
     }, z.core.$strict>;
     unread: z.ZodInt;
@@ -831,8 +831,8 @@ export declare const ThreadListSchema: z.ZodObject<{
             at: z.ZodNumber;
             kind: z.ZodEnum<{
                 call: "call";
-                out: "out";
                 in: "in";
+                out: "out";
             }>;
         }, z.core.$strict>;
         unread: z.ZodInt;
@@ -845,8 +845,8 @@ export type ThreadList = z.infer<typeof ThreadListSchema>;
 export declare const ThreadMessageSchema: z.ZodObject<{
     kind: z.ZodEnum<{
         call: "call";
-        out: "out";
         in: "in";
+        out: "out";
     }>;
     text: z.ZodNullable<z.ZodString>;
     at: z.ZodNumber;
@@ -867,8 +867,8 @@ export declare const ThreadSchema: z.ZodObject<{
     messages: z.ZodArray<z.ZodObject<{
         kind: z.ZodEnum<{
             call: "call";
-            out: "out";
             in: "in";
+            out: "out";
         }>;
         text: z.ZodNullable<z.ZodString>;
         at: z.ZodNumber;
@@ -982,15 +982,84 @@ export declare const OrgMailWantedSchema: z.ZodObject<{
     host: z.ZodString;
     port: z.ZodInt;
     security: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        none: "none";
         starttls: "starttls";
         tls: "tls";
-        none: "none";
     }>>>;
     username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     password: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     from: z.ZodString;
 }, z.core.$strict>;
 export type OrgMailWanted = z.infer<typeof OrgMailWantedSchema>;
+/**
+ * GET and PUT /v1/ops/mail: the SMTP account the BOX posts its letters through — what the operator
+ * stored, or the environment's two variables — how the last one went, and never the password. An
+ * org's own account (OrgMail) still wins over both.
+ */
+export declare const BoxMailSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    source: z.ZodNullable<z.ZodString>;
+    host: z.ZodNullable<z.ZodString>;
+    port: z.ZodNullable<z.ZodInt>;
+    security: z.ZodNullable<z.ZodString>;
+    username: z.ZodNullable<z.ZodString>;
+    from: z.ZodNullable<z.ZodString>;
+    verified_at: z.ZodNullable<z.ZodString>;
+    last_error: z.ZodNullable<z.ZodString>;
+}, z.core.$strict>;
+export type BoxMail = z.infer<typeof BoxMailSchema>;
+/**
+ * GET and PUT /v1/ops/brand, and `brand` on GET /.well-known/pinecall: what this box's letters and
+ * its sign-in page are called and painted with. Pinecall, its accent and no logo until the
+ * operator says.
+ */
+export declare const BoxBrandSchema: z.ZodObject<{
+    name: z.ZodString;
+    logo_url: z.ZodNullable<z.ZodString>;
+    accent: z.ZodString;
+}, z.core.$strict>;
+export type BoxBrand = z.infer<typeof BoxBrandSchema>;
+/**
+ * PUT /v1/ops/brand, the body. A field left out keeps what it had; an empty string goes back to
+ * the default — which for the logo is none at all, the only way to clear one.
+ */
+export declare const BoxBrandWantedSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    logo_url: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    accent: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+}, z.core.$strict>;
+export type BoxBrandWanted = z.infer<typeof BoxBrandWantedSchema>;
+/**
+ * One box-wide identity provider as the operator reads it: whether it is usable, the client this
+ * gateway is at it, and the URI to register there. Never the secret.
+ */
+export declare const BoxProviderSchema: z.ZodObject<{
+    configured: z.ZodBoolean;
+    client_id: z.ZodNullable<z.ZodString>;
+    redirect_uri: z.ZodString;
+}, z.core.$strict>;
+export type BoxProvider = z.infer<typeof BoxProviderSchema>;
+/**
+ * GET /v1/ops/signin: every provider this box can offer every org's people, wired or not, one key
+ * each. Only `google` today; a second is a key here and a row on the box.
+ */
+export declare const BoxSignInSchema: z.ZodObject<{
+    google: z.ZodObject<{
+        configured: z.ZodBoolean;
+        client_id: z.ZodNullable<z.ZodString>;
+        redirect_uri: z.ZodString;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type BoxSignIn = z.infer<typeof BoxSignInSchema>;
+/**
+ * PUT /v1/ops/signin/google, the body: the OAuth client the operator made at Google for this
+ * gateway. Replaced whole, the secret write-only; the issuer is Google's own and is not a field.
+ */
+export declare const BoxProviderWantedSchema: z.ZodObject<{
+    client_id: z.ZodString;
+    client_secret: z.ZodString;
+}, z.core.$strict>;
+export type BoxProviderWanted = z.infer<typeof BoxProviderWantedSchema>;
 /**
  * POST /v1/org/mail/test: one letter, waited for — the only door of this runtime that waits for a
  * mail server, because it is the one a person is watching.
@@ -1090,6 +1159,10 @@ export declare const KnowledgePushSchema: z.ZodObject<{
     files: z.ZodArray<z.ZodObject<{
         path: z.ZodString;
         text: z.ZodString;
+        mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            retrieved: "retrieved";
+            whole: "whole";
+        }>>>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
 export type KnowledgePush = z.infer<typeof KnowledgePushSchema>;
@@ -1143,13 +1216,15 @@ export declare const KnowledgeScoreSchema: z.ZodObject<{
 }, 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.
+ * PUT /v1/knowledge/{base}, the answer: which base, how many chunks it became, how long that took,
+ * and what its whole files weigh on every call.
  */
 export declare const KnowledgePushedSchema: z.ZodObject<{
     base: z.ZodString;
     chunks: z.ZodInt;
     took_ms: z.ZodNumber;
+    whole_tokens: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    notice: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
 }, 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. */
@@ -1368,8 +1443,9 @@ export declare const ExtractionRunSchema: z.ZodObject<{
 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.
+ * run it with. Asked by the worker for the call it serves, and by the app for a call of its own
+ * org — `this.knowledge.search` in a tool; 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<{
@@ -1390,6 +1466,25 @@ export declare const LookupResultSchema: z.ZodObject<{
     took_ms: z.ZodNumber;
 }, z.core.$strict>;
 export type LookupResult = z.infer<typeof LookupResultSchema>;
+/** One chunk search found: the file it came from, the heading it sits under, and its text. */
+export declare const FoundChunkSchema: z.ZodObject<{
+    path: z.ZodString;
+    heading: z.ZodNullable<z.ZodString>;
+    text: z.ZodString;
+}, z.core.$strict>;
+export type FoundChunk = z.infer<typeof FoundChunkSchema>;
+/**
+ * What search answers in a lookup's output: the best chunks of every base the agent reads, the
+ * best first. The app's `this.knowledge.search` hands the chunks to the tool that asked.
+ */
+export declare const SearchFoundSchema: z.ZodObject<{
+    chunks: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        heading: z.ZodNullable<z.ZodString>;
+        text: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SearchFound = z.infer<typeof SearchFoundSchema>;
 /**
  * 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
@@ -1420,7 +1515,6 @@ export declare const DialGuardsSchema: z.ZodObject<{
     dial_anywhere: z.ZodBoolean;
     per_minute: z.ZodInt;
     per_day: z.ZodInt;
-    countries: z.ZodArray<z.ZodString>;
     max_duration_s: z.ZodInt;
 }, z.core.$strict>;
 export type DialGuards = z.infer<typeof DialGuardsSchema>;
@@ -1437,7 +1531,6 @@ export declare const CarrierOutboundSchema: z.ZodObject<{
         dial_anywhere: z.ZodBoolean;
         per_minute: z.ZodInt;
         per_day: z.ZodInt;
-        countries: z.ZodArray<z.ZodString>;
         max_duration_s: z.ZodInt;
     }, z.core.$strict>;
 }, z.core.$strict>;
@@ -1451,3 +1544,595 @@ export declare const OutboundProvisionedSchema: z.ZodObject<{
     address: z.ZodOptional<z.ZodNullable<z.ZodString>>;
 }, z.core.$strict>;
 export type OutboundProvisioned = z.infer<typeof OutboundProvisionedSchema>;
+/**
+ * An agent's tuning: what the org set over what the app declared, per world and per corner. Every
+ * field is optional; one left out is not set, and what the app declared — or the runtime's own
+ * default — stands for it.
+ */
+export declare const TuningBodySchema: z.ZodObject<{
+    voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+    }, z.core.$strict>>>;
+    hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, z.core.$strict>>>;
+    turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+    }, z.core.$strict>>>;
+    memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>>;
+    knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+        base: z.ZodString;
+        mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+            retrieved: "retrieved";
+            tool: "tool";
+        }>>>;
+        k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+    }, z.core.$strict>>>>;
+}, z.core.$strict>;
+export type TuningBody = z.infer<typeof TuningBodySchema>;
+/**
+ * One kept version of an agent's tuning: whose corner, which version, who set it and when, and
+ * what it says.
+ */
+export declare const TuningRowSchema: z.ZodObject<{
+    holder: z.ZodString;
+    version: z.ZodInt;
+    author: z.ZodString;
+    note: z.ZodNullable<z.ZodString>;
+    set_at: z.ZodNumber;
+    config: z.ZodObject<{
+        voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strict>>>;
+        hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+        turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        }, z.core.$strict>>>;
+        memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>>;
+        knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            base: z.ZodString;
+            mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                retrieved: "retrieved";
+                tool: "tool";
+            }>>>;
+            k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type TuningRow = z.infer<typeof TuningRowSchema>;
+/**
+ * GET /v1/agents/{slug}/settings: the agent's tuning as this key sees it — its own corner's, the
+ * team's and production's, each corner's own newest row, or null when that corner set nothing.
+ */
+export declare const TuningAnswerSchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    yours: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    team: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    production: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TuningAnswer = z.infer<typeof TuningAnswerSchema>;
+/**
+ * PUT /v1/agents/{slug}/settings, the body: the whole set, the version it was read at, why, and
+ * whose corner.
+ */
+export declare const TuningPutSchema: z.ZodObject<{
+    config: z.ZodObject<{
+        voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+        }, z.core.$strict>>>;
+        hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        }, z.core.$strict>>>;
+        turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+        }, z.core.$strict>>>;
+        memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strict>>>;
+        knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+            base: z.ZodString;
+            mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                retrieved: "retrieved";
+                tool: "tool";
+            }>>>;
+            k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+        }, z.core.$strict>>>>;
+    }, z.core.$strict>;
+    if_version: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodInt>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    team: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type TuningPut = z.infer<typeof TuningPutSchema>;
+/** GET /v1/agents/{slug}/settings/history: one corner's versions, newest first. */
+export declare const TuningHistorySchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    holder: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type TuningHistory = z.infer<typeof TuningHistorySchema>;
+/**
+ * GET /v1/agents/{slug}/settings/diff: what this key's corner reads against another corner's
+ * newest, and which fields differ.
+ */
+export declare const TuningDiffSchema: z.ZodObject<{
+    ours: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    theirs: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    changed: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type TuningDiff = z.infer<typeof TuningDiffSchema>;
+/**
+ * POST /v1/agents/{slug}/settings/rollback, the body: which version to bring back. It comes back
+ * as a NEW version; nothing is deleted.
+ */
+export declare const RollbackSchema: z.ZodObject<{
+    version: z.ZodInt;
+    team: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type Rollback = z.infer<typeof RollbackSchema>;
+/**
+ * The org's lexicon: how the voice says the words it would get wrong, and the words the ears must
+ * know. Shared by every agent of the org, laid over each one's own says and hears.
+ */
+export declare const LexiconBodySchema: z.ZodObject<{
+    said: z.ZodArray<z.ZodObject<{
+        word: z.ZodString;
+        spoken: z.ZodString;
+    }, z.core.$strict>>;
+    heard: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type LexiconBody = z.infer<typeof LexiconBodySchema>;
+/** One kept version of the org's lexicon. */
+export declare const LexiconRowSchema: z.ZodObject<{
+    holder: z.ZodString;
+    version: z.ZodInt;
+    author: z.ZodString;
+    note: z.ZodNullable<z.ZodString>;
+    set_at: z.ZodNumber;
+    lexicon: z.ZodObject<{
+        said: z.ZodArray<z.ZodObject<{
+            word: z.ZodString;
+            spoken: z.ZodString;
+        }, z.core.$strict>>;
+        heard: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type LexiconRow = z.infer<typeof LexiconRowSchema>;
+/**
+ * GET /v1/lexicon: the org's words as this key sees them — its own corner's, the team's and
+ * production's, each corner's own newest, or null.
+ */
+export declare const LexiconAnswerSchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    yours: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    team: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    production: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LexiconAnswer = z.infer<typeof LexiconAnswerSchema>;
+/** PUT /v1/lexicon, the body: the whole lexicon, the version it was read at, why, and whose corner. */
+export declare const LexiconPutSchema: z.ZodObject<{
+    lexicon: z.ZodObject<{
+        said: z.ZodArray<z.ZodObject<{
+            word: z.ZodString;
+            spoken: z.ZodString;
+        }, z.core.$strict>>;
+        heard: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>;
+    if_version: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodInt>>>;
+    note: z.ZodOptional<z.ZodNullable<z.ZodNullable<z.ZodString>>>;
+    team: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+}, z.core.$strict>;
+export type LexiconPut = z.infer<typeof LexiconPutSchema>;
+/** GET /v1/lexicon/history: one corner's versions, newest first. */
+export declare const LexiconHistorySchema: z.ZodObject<{
+    world: z.ZodEnum<{
+        production: "production";
+        sandbox: "sandbox";
+    }>;
+    holder: z.ZodString;
+    rows: z.ZodArray<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type LexiconHistory = z.infer<typeof LexiconHistorySchema>;
+/**
+ * GET /v1/calls/{call}/settings: the exact tuning and lexicon a call was built on, by the versions
+ * its head row recorded.
+ */
+export declare const CallTuningSchema: z.ZodObject<{
+    config_version: z.ZodNullable<z.ZodInt>;
+    lexicon_version: z.ZodNullable<z.ZodInt>;
+    config: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        config: z.ZodObject<{
+            voice: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            tts_model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            stt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            llm: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            greeting: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                say: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                reply: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+                allow_interruptions: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+            }, z.core.$strict>>>;
+            hangup: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                when: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+            }, z.core.$strict>>>;
+            turn: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                min_interruption_words: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                endpointing_ms: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+            }, z.core.$strict>>>;
+            memory: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                remember: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+                forget: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+            }, z.core.$strict>>>;
+            knowledge: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodObject<{
+                base: z.ZodString;
+                mode: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+                    retrieved: "retrieved";
+                    tool: "tool";
+                }>>>;
+                k: z.ZodOptional<z.ZodNullable<z.ZodInt>>;
+                min_score: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            }, z.core.$strict>>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+    lexicon: z.ZodNullable<z.ZodObject<{
+        holder: z.ZodString;
+        version: z.ZodInt;
+        author: z.ZodString;
+        note: z.ZodNullable<z.ZodString>;
+        set_at: z.ZodNumber;
+        lexicon: z.ZodObject<{
+            said: z.ZodArray<z.ZodObject<{
+                word: z.ZodString;
+                spoken: z.ZodString;
+            }, z.core.$strict>>;
+            heard: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CallTuning = z.infer<typeof CallTuningSchema>;
+/** One base and the agents whose settings attach it. */
+export declare const KnowledgeUseSchema: z.ZodObject<{
+    base: z.ZodString;
+    agents: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type KnowledgeUse = z.infer<typeof KnowledgeUseSchema>;
+/**
+ * GET /v1/knowledge/attached: which agents read each base, off every agent's newest settings in
+ * this world.
+ */
+export declare const KnowledgeUsesSchema: z.ZodObject<{
+    bases: z.ZodArray<z.ZodObject<{
+        base: z.ZodString;
+        agents: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type KnowledgeUses = z.infer<typeof KnowledgeUsesSchema>;