@mistralai/mistralai 1.13.0 → 1.14.1

package/src/models/components/realtimetranscriptionsessionupdated.ts

@@ -0,0 +1,64 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  RealtimeTranscriptionSession,
+  RealtimeTranscriptionSession$inboundSchema,
+  RealtimeTranscriptionSession$Outbound,
+  RealtimeTranscriptionSession$outboundSchema,
+} from "./realtimetranscriptionsession.js";
+
+export type RealtimeTranscriptionSessionUpdated = {
+  type?: "session.updated" | undefined;
+  session: RealtimeTranscriptionSession;
+};
+
+/** @internal */
+export const RealtimeTranscriptionSessionUpdated$inboundSchema: z.ZodType<
+  RealtimeTranscriptionSessionUpdated,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("session.updated").default("session.updated"),
+  session: RealtimeTranscriptionSession$inboundSchema,
+});
+/** @internal */
+export type RealtimeTranscriptionSessionUpdated$Outbound = {
+  type: "session.updated";
+  session: RealtimeTranscriptionSession$Outbound;
+};
+
+/** @internal */
+export const RealtimeTranscriptionSessionUpdated$outboundSchema: z.ZodType<
+  RealtimeTranscriptionSessionUpdated$Outbound,
+  z.ZodTypeDef,
+  RealtimeTranscriptionSessionUpdated
+> = z.object({
+  type: z.literal("session.updated").default("session.updated" as const),
+  session: RealtimeTranscriptionSession$outboundSchema,
+});
+
+export function realtimeTranscriptionSessionUpdatedToJSON(
+  realtimeTranscriptionSessionUpdated: RealtimeTranscriptionSessionUpdated,
+): string {
+  return JSON.stringify(
+    RealtimeTranscriptionSessionUpdated$outboundSchema.parse(
+      realtimeTranscriptionSessionUpdated,
+    ),
+  );
+}
+export function realtimeTranscriptionSessionUpdatedFromJSON(
+  jsonString: string,
+): SafeParseResult<RealtimeTranscriptionSessionUpdated, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      RealtimeTranscriptionSessionUpdated$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'RealtimeTranscriptionSessionUpdated' from JSON`,
+  );
+}

package/src/models/components/realtimetranscriptionsessionupdatemessage.ts

@@ -0,0 +1,71 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  RealtimeTranscriptionSessionUpdatePayload,
+  RealtimeTranscriptionSessionUpdatePayload$inboundSchema,
+  RealtimeTranscriptionSessionUpdatePayload$Outbound,
+  RealtimeTranscriptionSessionUpdatePayload$outboundSchema,
+} from "./realtimetranscriptionsessionupdatepayload.js";
+
+export type RealtimeTranscriptionSessionUpdateMessage = {
+  type?: "session.update" | undefined;
+  session: RealtimeTranscriptionSessionUpdatePayload;
+};
+
+/** @internal */
+export const RealtimeTranscriptionSessionUpdateMessage$inboundSchema: z.ZodType<
+  RealtimeTranscriptionSessionUpdateMessage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("session.update").default("session.update"),
+  session: RealtimeTranscriptionSessionUpdatePayload$inboundSchema,
+});
+/** @internal */
+export type RealtimeTranscriptionSessionUpdateMessage$Outbound = {
+  type: "session.update";
+  session: RealtimeTranscriptionSessionUpdatePayload$Outbound;
+};
+
+/** @internal */
+export const RealtimeTranscriptionSessionUpdateMessage$outboundSchema:
+  z.ZodType<
+    RealtimeTranscriptionSessionUpdateMessage$Outbound,
+    z.ZodTypeDef,
+    RealtimeTranscriptionSessionUpdateMessage
+  > = z.object({
+    type: z.literal("session.update").default("session.update" as const),
+    session: RealtimeTranscriptionSessionUpdatePayload$outboundSchema,
+  });
+
+export function realtimeTranscriptionSessionUpdateMessageToJSON(
+  realtimeTranscriptionSessionUpdateMessage:
+    RealtimeTranscriptionSessionUpdateMessage,
+): string {
+  return JSON.stringify(
+    RealtimeTranscriptionSessionUpdateMessage$outboundSchema.parse(
+      realtimeTranscriptionSessionUpdateMessage,
+    ),
+  );
+}
+export function realtimeTranscriptionSessionUpdateMessageFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  RealtimeTranscriptionSessionUpdateMessage,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      RealtimeTranscriptionSessionUpdateMessage$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'RealtimeTranscriptionSessionUpdateMessage' from JSON`,
+  );
+}

package/src/models/components/realtimetranscriptionsessionupdatepayload.ts

@@ -0,0 +1,88 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  AudioFormat,
+  AudioFormat$inboundSchema,
+  AudioFormat$Outbound,
+  AudioFormat$outboundSchema,
+} from "./audioformat.js";
+
+export type RealtimeTranscriptionSessionUpdatePayload = {
+  /**
+   * Set before sending audio. Audio format updates are rejected after audio starts.
+   */
+  audioFormat?: AudioFormat | null | undefined;
+  /**
+   * Set before sending audio. Streaming delay updates are rejected after audio starts.
+   */
+  targetStreamingDelayMs?: number | null | undefined;
+};
+
+/** @internal */
+export const RealtimeTranscriptionSessionUpdatePayload$inboundSchema: z.ZodType<
+  RealtimeTranscriptionSessionUpdatePayload,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  audio_format: z.nullable(AudioFormat$inboundSchema).optional(),
+  target_streaming_delay_ms: z.nullable(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "audio_format": "audioFormat",
+    "target_streaming_delay_ms": "targetStreamingDelayMs",
+  });
+});
+/** @internal */
+export type RealtimeTranscriptionSessionUpdatePayload$Outbound = {
+  audio_format?: AudioFormat$Outbound | null | undefined;
+  target_streaming_delay_ms?: number | null | undefined;
+};
+
+/** @internal */
+export const RealtimeTranscriptionSessionUpdatePayload$outboundSchema:
+  z.ZodType<
+    RealtimeTranscriptionSessionUpdatePayload$Outbound,
+    z.ZodTypeDef,
+    RealtimeTranscriptionSessionUpdatePayload
+  > = z.object({
+    audioFormat: z.nullable(AudioFormat$outboundSchema).optional(),
+    targetStreamingDelayMs: z.nullable(z.number().int()).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      audioFormat: "audio_format",
+      targetStreamingDelayMs: "target_streaming_delay_ms",
+    });
+  });
+
+export function realtimeTranscriptionSessionUpdatePayloadToJSON(
+  realtimeTranscriptionSessionUpdatePayload:
+    RealtimeTranscriptionSessionUpdatePayload,
+): string {
+  return JSON.stringify(
+    RealtimeTranscriptionSessionUpdatePayload$outboundSchema.parse(
+      realtimeTranscriptionSessionUpdatePayload,
+    ),
+  );
+}
+export function realtimeTranscriptionSessionUpdatePayloadFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  RealtimeTranscriptionSessionUpdatePayload,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      RealtimeTranscriptionSessionUpdatePayload$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'RealtimeTranscriptionSessionUpdatePayload' from JSON`,
+  );
+}

package/src/models/components/referencechunk.ts

@@ -5,37 +5,22 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const ReferenceChunkType = {
-  Reference: "reference",
-} as const;
-export type ReferenceChunkType = ClosedEnum<typeof ReferenceChunkType>;
-
 export type ReferenceChunk = {
+  type?: "reference" | undefined;
   referenceIds: Array<number>;
-  type?: ReferenceChunkType | undefined;
 };
 
-/** @internal */
-export const ReferenceChunkType$inboundSchema: z.ZodNativeEnum<
-  typeof ReferenceChunkType
-> = z.nativeEnum(ReferenceChunkType);
-/** @internal */
-export const ReferenceChunkType$outboundSchema: z.ZodNativeEnum<
-  typeof ReferenceChunkType
-> = ReferenceChunkType$inboundSchema;
-
 /** @internal */
 export const ReferenceChunk$inboundSchema: z.ZodType<
   ReferenceChunk,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  type: z.literal("reference").default("reference"),
   reference_ids: z.array(z.number().int()),
-  type: ReferenceChunkType$inboundSchema.default("reference"),
 }).transform((v) => {
   return remap$(v, {
     "reference_ids": "referenceIds",
@@ -43,8 +28,8 @@ export const ReferenceChunk$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type ReferenceChunk$Outbound = {
+  type: "reference";
   reference_ids: Array<number>;
-  type: string;
 };
 
 /** @internal */
@@ -53,8 +38,8 @@ export const ReferenceChunk$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ReferenceChunk
 > = z.object({
+  type: z.literal("reference").default("reference" as const),
   referenceIds: z.array(z.number().int()),
-  type: ReferenceChunkType$outboundSchema.default("reference"),
 }).transform((v) => {
   return remap$(v, {
     referenceIds: "reference_ids",

package/src/models/components/responsedoneevent.ts

@@ -5,7 +5,6 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import {
@@ -13,29 +12,19 @@ import {
   ConversationUsageInfo$inboundSchema,
 } from "./conversationusageinfo.js";
 
-export const ResponseDoneEventType = {
-  ConversationResponseDone: "conversation.response.done",
-} as const;
-export type ResponseDoneEventType = ClosedEnum<typeof ResponseDoneEventType>;
-
 export type ResponseDoneEvent = {
-  type: ResponseDoneEventType | undefined;
+  type?: "conversation.response.done" | undefined;
   createdAt?: Date | undefined;
   usage: ConversationUsageInfo;
 };
 
-/** @internal */
-export const ResponseDoneEventType$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseDoneEventType
-> = z.nativeEnum(ResponseDoneEventType);
-
 /** @internal */
 export const ResponseDoneEvent$inboundSchema: z.ZodType<
   ResponseDoneEvent,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: ResponseDoneEventType$inboundSchema.default(
+  type: z.literal("conversation.response.done").default(
     "conversation.response.done",
   ),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))

package/src/models/components/responseerrorevent.ts

@@ -5,34 +5,23 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const ResponseErrorEventType = {
-  ConversationResponseError: "conversation.response.error",
-} as const;
-export type ResponseErrorEventType = ClosedEnum<typeof ResponseErrorEventType>;
-
 export type ResponseErrorEvent = {
-  type: ResponseErrorEventType | undefined;
+  type?: "conversation.response.error" | undefined;
   createdAt?: Date | undefined;
   message: string;
   code: number;
 };
 
-/** @internal */
-export const ResponseErrorEventType$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseErrorEventType
-> = z.nativeEnum(ResponseErrorEventType);
-
 /** @internal */
 export const ResponseErrorEvent$inboundSchema: z.ZodType<
   ResponseErrorEvent,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: ResponseErrorEventType$inboundSchema.default(
+  type: z.literal("conversation.response.error").default(
     "conversation.response.error",
   ),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))

package/src/models/components/responsestartedevent.ts

@@ -5,35 +5,22 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const ResponseStartedEventType = {
-  ConversationResponseStarted: "conversation.response.started",
-} as const;
-export type ResponseStartedEventType = ClosedEnum<
-  typeof ResponseStartedEventType
->;
-
 export type ResponseStartedEvent = {
-  type: ResponseStartedEventType | undefined;
+  type?: "conversation.response.started" | undefined;
   createdAt?: Date | undefined;
   conversationId: string;
 };
 
-/** @internal */
-export const ResponseStartedEventType$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseStartedEventType
-> = z.nativeEnum(ResponseStartedEventType);
-
 /** @internal */
 export const ResponseStartedEvent$inboundSchema: z.ZodType<
   ResponseStartedEvent,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: ResponseStartedEventType$inboundSchema.default(
+  type: z.literal("conversation.response.started").default(
     "conversation.response.started",
   ),
   created_at: z.string().datetime({ offset: true }).transform(v => new Date(v))

package/src/models/components/systemmessage.ts

@@ -3,7 +3,6 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
 import {
   SystemMessageContentChunks,
   SystemMessageContentChunks$Outbound,
@@ -12,14 +11,9 @@ import {
 
 export type SystemMessageContent = string | Array<SystemMessageContentChunks>;
 
-export const Role = {
-  System: "system",
-} as const;
-export type Role = ClosedEnum<typeof Role>;
-
 export type SystemMessage = {
+  role?: "system" | undefined;
   content: string | Array<SystemMessageContentChunks>;
-  role?: Role | undefined;
 };
 
 /** @internal */
@@ -42,15 +36,10 @@ export function systemMessageContentToJSON(
   );
 }
 
-/** @internal */
-export const Role$outboundSchema: z.ZodNativeEnum<typeof Role> = z.nativeEnum(
-  Role,
-);
-
 /** @internal */
 export type SystemMessage$Outbound = {
+  role: "system";
   content: string | Array<SystemMessageContentChunks$Outbound>;
-  role: string;
 };
 
 /** @internal */
@@ -59,11 +48,11 @@ export const SystemMessage$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   SystemMessage
 > = z.object({
+  role: z.literal("system").default("system" as const),
   content: z.union([
     z.string(),
     z.array(SystemMessageContentChunks$outboundSchema),
   ]),
-  role: Role$outboundSchema.default("system"),
 });
 
 export function systemMessageToJSON(systemMessage: SystemMessage): string {

package/src/models/components/textchunk.ts

@@ -4,42 +4,27 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const TextChunkType = {
-  Text: "text",
-} as const;
-export type TextChunkType = ClosedEnum<typeof TextChunkType>;
-
 export type TextChunk = {
+  type?: "text" | undefined;
   text: string;
-  type?: TextChunkType | undefined;
 };
 
-/** @internal */
-export const TextChunkType$inboundSchema: z.ZodNativeEnum<
-  typeof TextChunkType
-> = z.nativeEnum(TextChunkType);
-/** @internal */
-export const TextChunkType$outboundSchema: z.ZodNativeEnum<
-  typeof TextChunkType
-> = TextChunkType$inboundSchema;
-
 /** @internal */
 export const TextChunk$inboundSchema: z.ZodType<
   TextChunk,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  type: z.literal("text").default("text"),
   text: z.string(),
-  type: TextChunkType$inboundSchema.default("text"),
 });
 /** @internal */
 export type TextChunk$Outbound = {
+  type: "text";
   text: string;
-  type: string;
 };
 
 /** @internal */
@@ -48,8 +33,8 @@ export const TextChunk$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   TextChunk
 > = z.object({
+  type: z.literal("text").default("text" as const),
   text: z.string(),
-  type: TextChunkType$outboundSchema.default("text"),
 });
 
 export function textChunkToJSON(textChunk: TextChunk): string {

package/src/models/components/thinkchunk.ts

@@ -4,36 +4,27 @@
 
 import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-import {
-  ReferenceChunk,
-  ReferenceChunk$inboundSchema,
-  ReferenceChunk$Outbound,
-  ReferenceChunk$outboundSchema,
-} from "./referencechunk.js";
 import {
   TextChunk,
   TextChunk$inboundSchema,
   TextChunk$Outbound,
   TextChunk$outboundSchema,
 } from "./textchunk.js";
+import {
+  ToolReferenceChunk,
+  ToolReferenceChunk$inboundSchema,
+  ToolReferenceChunk$Outbound,
+  ToolReferenceChunk$outboundSchema,
+} from "./toolreferencechunk.js";
 
-export type Thinking = ReferenceChunk | TextChunk;
-
-export const ThinkChunkType = {
-  Thinking: "thinking",
-} as const;
-export type ThinkChunkType = ClosedEnum<typeof ThinkChunkType>;
+export type Thinking = ToolReferenceChunk | TextChunk;
 
 export type ThinkChunk = {
-  thinking: Array<ReferenceChunk | TextChunk>;
-  /**
-   * Whether the thinking chunk is closed or not. Currently only used for prefixing.
-   */
+  type?: "thinking" | undefined;
+  thinking: Array<ToolReferenceChunk | TextChunk>;
   closed?: boolean | undefined;
-  type?: ThinkChunkType | undefined;
 };
 
 /** @internal */
@@ -41,16 +32,18 @@ export const Thinking$inboundSchema: z.ZodType<
   Thinking,
   z.ZodTypeDef,
   unknown
-> = z.union([ReferenceChunk$inboundSchema, TextChunk$inboundSchema]);
+> = z.union([ToolReferenceChunk$inboundSchema, TextChunk$inboundSchema]);
 /** @internal */
-export type Thinking$Outbound = ReferenceChunk$Outbound | TextChunk$Outbound;
+export type Thinking$Outbound =
+  | ToolReferenceChunk$Outbound
+  | TextChunk$Outbound;
 
 /** @internal */
 export const Thinking$outboundSchema: z.ZodType<
   Thinking$Outbound,
   z.ZodTypeDef,
   Thinking
-> = z.union([ReferenceChunk$outboundSchema, TextChunk$outboundSchema]);
+> = z.union([ToolReferenceChunk$outboundSchema, TextChunk$outboundSchema]);
 
 export function thinkingToJSON(thinking: Thinking): string {
   return JSON.stringify(Thinking$outboundSchema.parse(thinking));
@@ -65,32 +58,23 @@ export function thinkingFromJSON(
   );
 }
 
-/** @internal */
-export const ThinkChunkType$inboundSchema: z.ZodNativeEnum<
-  typeof ThinkChunkType
-> = z.nativeEnum(ThinkChunkType);
-/** @internal */
-export const ThinkChunkType$outboundSchema: z.ZodNativeEnum<
-  typeof ThinkChunkType
-> = ThinkChunkType$inboundSchema;
-
 /** @internal */
 export const ThinkChunk$inboundSchema: z.ZodType<
   ThinkChunk,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  type: z.literal("thinking").default("thinking"),
   thinking: z.array(
-    z.union([ReferenceChunk$inboundSchema, TextChunk$inboundSchema]),
+    z.union([ToolReferenceChunk$inboundSchema, TextChunk$inboundSchema]),
   ),
-  closed: z.boolean().optional(),
-  type: ThinkChunkType$inboundSchema.default("thinking"),
+  closed: z.boolean().default(true),
 });
 /** @internal */
 export type ThinkChunk$Outbound = {
-  thinking: Array<ReferenceChunk$Outbound | TextChunk$Outbound>;
-  closed?: boolean | undefined;
-  type: string;
+  type: "thinking";
+  thinking: Array<ToolReferenceChunk$Outbound | TextChunk$Outbound>;
+  closed: boolean;
 };
 
 /** @internal */
@@ -99,11 +83,11 @@ export const ThinkChunk$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   ThinkChunk
 > = z.object({
+  type: z.literal("thinking").default("thinking" as const),
   thinking: z.array(
-    z.union([ReferenceChunk$outboundSchema, TextChunk$outboundSchema]),
+    z.union([ToolReferenceChunk$outboundSchema, TextChunk$outboundSchema]),
   ),
-  closed: z.boolean().optional(),
-  type: ThinkChunkType$outboundSchema.default("thinking"),
+  closed: z.boolean().default(true),
 });
 
 export function thinkChunkToJSON(thinkChunk: ThinkChunk): string {

package/src/models/components/timestampgranularity.ts

@@ -7,6 +7,7 @@ import { ClosedEnum } from "../../types/enums.js";
 
 export const TimestampGranularity = {
   Segment: "segment",
+  Word: "word",
 } as const;
 export type TimestampGranularity = ClosedEnum<typeof TimestampGranularity>;
 

package/src/models/components/toolcallconfirmation.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { ClosedEnum } from "../../types/enums.js";
+
+export const Confirmation = {
+  Allow: "allow",
+  Deny: "deny",
+} as const;
+export type Confirmation = ClosedEnum<typeof Confirmation>;
+
+export type ToolCallConfirmation = {
+  toolCallId: string;
+  confirmation: Confirmation;
+};
+
+/** @internal */
+export const Confirmation$outboundSchema: z.ZodNativeEnum<typeof Confirmation> =
+  z.nativeEnum(Confirmation);
+
+/** @internal */
+export type ToolCallConfirmation$Outbound = {
+  tool_call_id: string;
+  confirmation: string;
+};
+
+/** @internal */
+export const ToolCallConfirmation$outboundSchema: z.ZodType<
+  ToolCallConfirmation$Outbound,
+  z.ZodTypeDef,
+  ToolCallConfirmation
+> = z.object({
+  toolCallId: z.string(),
+  confirmation: Confirmation$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    toolCallId: "tool_call_id",
+  });
+});
+
+export function toolCallConfirmationToJSON(
+  toolCallConfirmation: ToolCallConfirmation,
+): string {
+  return JSON.stringify(
+    ToolCallConfirmation$outboundSchema.parse(toolCallConfirmation),
+  );
+}