@mistralai/mistralai 1.15.1 → 2.0.0

package/src/models/components/audiochunk.ts

@@ -3,30 +3,27 @@
  * @generated-id: 561de42bd77e
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 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";
 
 export type AudioChunk = {
-  type?: "input_audio" | undefined;
+  type: "input_audio";
   inputAudio: string;
 };
 
 /** @internal */
-export const AudioChunk$inboundSchema: z.ZodType<
-  AudioChunk,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: z.literal("input_audio").default("input_audio"),
-  input_audio: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "input_audio": "inputAudio",
+export const AudioChunk$inboundSchema: z.ZodType<AudioChunk, unknown> = z
+  .object({
+    type: z.literal("input_audio"),
+    input_audio: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "input_audio": "inputAudio",
+    });
   });
-});
 /** @internal */
 export type AudioChunk$Outbound = {
   type: "input_audio";
@@ -36,10 +33,9 @@ export type AudioChunk$Outbound = {
 /** @internal */
 export const AudioChunk$outboundSchema: z.ZodType<
   AudioChunk$Outbound,
-  z.ZodTypeDef,
   AudioChunk
 > = z.object({
-  type: z.literal("input_audio").default("input_audio" as const),
+  type: z.literal("input_audio"),
   inputAudio: z.string(),
 }).transform((v) => {
   return remap$(v, {

package/src/models/components/audiocontent.ts

@@ -3,12 +3,9 @@
  * @generated-id: 905a70dfea53
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
-import {
-  collectExtraKeys as collectExtraKeys$,
-  safeParse,
-} from "../../lib/schemas.js";
+import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 import { Annotations, Annotations$inboundSchema } from "./annotations.js";
@@ -17,34 +14,27 @@ import { Annotations, Annotations$inboundSchema } from "./annotations.js";
  * Audio content for a message.
  */
 export type AudioContent = {
-  type?: "audio" | undefined;
+  type: "audio";
   data: string;
   mimeType: string;
   annotations?: Annotations | null | undefined;
   meta?: { [k: string]: any } | null | undefined;
-  additionalProperties?: { [k: string]: any } | undefined;
+  [additionalProperties: string]: unknown;
 };
 
 /** @internal */
-export const AudioContent$inboundSchema: z.ZodType<
-  AudioContent,
-  z.ZodTypeDef,
-  unknown
-> = collectExtraKeys$(
-  z.object({
-    type: z.literal("audio").default("audio").optional(),
+export const AudioContent$inboundSchema: z.ZodType<AudioContent, unknown> = z
+  .object({
+    type: z.literal("audio"),
     data: z.string(),
     mimeType: z.string(),
     annotations: z.nullable(Annotations$inboundSchema).optional(),
-    _meta: z.nullable(z.record(z.any())).optional(),
-  }).catchall(z.any()),
-  "additionalProperties",
-  true,
-).transform((v) => {
-  return remap$(v, {
-    "_meta": "meta",
+    _meta: z.nullable(z.record(z.string(), z.any())).optional(),
+  }).catchall(z.any()).transform((v) => {
+    return remap$(v, {
+      "_meta": "meta",
+    });
   });
-});
 
 export function audioContentFromJSON(
   jsonString: string,

package/src/models/components/audioencoding.ts

@@ -3,7 +3,7 @@
  * @generated-id: 159b727e2b13
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import * as openEnums from "../../types/enums.js";
 import { OpenEnum } from "../../types/enums.js";
 
@@ -18,14 +18,8 @@ export const AudioEncoding = {
 export type AudioEncoding = OpenEnum<typeof AudioEncoding>;
 
 /** @internal */
-export const AudioEncoding$inboundSchema: z.ZodType<
-  AudioEncoding,
-  z.ZodTypeDef,
-  unknown
-> = openEnums.inboundSchema(AudioEncoding);
+export const AudioEncoding$inboundSchema: z.ZodType<AudioEncoding, unknown> =
+  openEnums.inboundSchema(AudioEncoding);
 /** @internal */
-export const AudioEncoding$outboundSchema: z.ZodType<
-  string,
-  z.ZodTypeDef,
-  AudioEncoding
-> = openEnums.outboundSchema(AudioEncoding);
+export const AudioEncoding$outboundSchema: z.ZodType<string, AudioEncoding> =
+  openEnums.outboundSchema(AudioEncoding);

package/src/models/components/audioformat.ts

@@ -3,7 +3,7 @@
  * @generated-id: 91222548de47
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
@@ -20,18 +20,15 @@ export type AudioFormat = {
 };
 
 /** @internal */
-export const AudioFormat$inboundSchema: z.ZodType<
-  AudioFormat,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  encoding: AudioEncoding$inboundSchema,
-  sample_rate: z.number().int(),
-}).transform((v) => {
-  return remap$(v, {
-    "sample_rate": "sampleRate",
+export const AudioFormat$inboundSchema: z.ZodType<AudioFormat, unknown> = z
+  .object({
+    encoding: AudioEncoding$inboundSchema,
+    sample_rate: z.int(),
+  }).transform((v) => {
+    return remap$(v, {
+      "sample_rate": "sampleRate",
+    });
   });
-});
 /** @internal */
 export type AudioFormat$Outbound = {
   encoding: string;
@@ -41,11 +38,10 @@ export type AudioFormat$Outbound = {
 /** @internal */
 export const AudioFormat$outboundSchema: z.ZodType<
   AudioFormat$Outbound,
-  z.ZodTypeDef,
   AudioFormat
 > = z.object({
   encoding: AudioEncoding$outboundSchema,
-  sampleRate: z.number().int(),
+  sampleRate: z.int(),
 }).transform((v) => {
   return remap$(v, {
     sampleRate: "sample_rate",

package/src/models/components/audiotranscriptionrequest.ts

@@ -3,7 +3,7 @@
  * @generated-id: f401897dbaf6
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { blobLikeSchema } from "../../types/blobs.js";
 import { FileT, FileT$Outbound, FileT$outboundSchema } from "./file.js";
@@ -57,7 +57,6 @@ export type AudioTranscriptionRequest$Outbound = {
 /** @internal */
 export const AudioTranscriptionRequest$outboundSchema: z.ZodType<
   AudioTranscriptionRequest$Outbound,
-  z.ZodTypeDef,
   AudioTranscriptionRequest
 > = z.object({
   model: z.string(),

package/src/models/components/audiotranscriptionrequeststream.ts

@@ -3,7 +3,7 @@
  * @generated-id: d436d38ecd10
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { blobLikeSchema } from "../../types/blobs.js";
 import { FileT, FileT$Outbound, FileT$outboundSchema } from "./file.js";
@@ -54,7 +54,6 @@ export type AudioTranscriptionRequestStream$Outbound = {
 /** @internal */
 export const AudioTranscriptionRequestStream$outboundSchema: z.ZodType<
   AudioTranscriptionRequestStream$Outbound,
-  z.ZodTypeDef,
   AudioTranscriptionRequestStream
 > = z.object({
   model: z.string(),

package/src/models/components/authdata.ts

@@ -3,7 +3,7 @@
  * @generated-id: 67db7c9b1d99
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 
 export type AuthData = {
@@ -18,19 +18,16 @@ export type AuthData$Outbound = {
 };
 
 /** @internal */
-export const AuthData$outboundSchema: z.ZodType<
-  AuthData$Outbound,
-  z.ZodTypeDef,
-  AuthData
-> = z.object({
-  clientId: z.string(),
-  clientSecret: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    clientId: "client_id",
-    clientSecret: "client_secret",
+export const AuthData$outboundSchema: z.ZodType<AuthData$Outbound, AuthData> = z
+  .object({
+    clientId: z.string(),
+    clientSecret: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      clientId: "client_id",
+      clientSecret: "client_secret",
+    });
   });
-});
 
 export function authDataToJSON(authData: AuthData): string {
   return JSON.stringify(AuthData$outboundSchema.parse(authData));

package/src/models/components/authurlresponse.ts

@@ -0,0 +1,38 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 2438b56452ed
+ */
+
+import * as z from "zod/v4";
+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";
+
+export type AuthUrlResponse = {
+  authUrl: string;
+  ttl: number;
+};
+
+/** @internal */
+export const AuthUrlResponse$inboundSchema: z.ZodType<
+  AuthUrlResponse,
+  unknown
+> = z.object({
+  auth_url: z.string(),
+  ttl: z.int(),
+}).transform((v) => {
+  return remap$(v, {
+    "auth_url": "authUrl",
+  });
+});
+
+export function authUrlResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<AuthUrlResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AuthUrlResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AuthUrlResponse' from JSON`,
+  );
+}

package/src/models/components/basefielddefinition.ts

@@ -3,14 +3,15 @@
  * @generated-id: c5cc252be3b5
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const BaseFieldDefinitionType = {
+export const TypeEnum = {
   Enum: "ENUM",
   Text: "TEXT",
   Int: "INT",
@@ -19,11 +20,9 @@ export const BaseFieldDefinitionType = {
   Timestamp: "TIMESTAMP",
   Array: "ARRAY",
 } as const;
-export type BaseFieldDefinitionType = ClosedEnum<
-  typeof BaseFieldDefinitionType
->;
+export type TypeEnum = OpenEnum<typeof TypeEnum>;
 
-export const SupportedOperators = {
+export const SupportedOperator = {
   Lt: "lt",
   Lte: "lte",
   Gt: "gt",
@@ -44,37 +43,36 @@ export const SupportedOperators = {
   Excludes: "excludes",
   LenEq: "len_eq",
 } as const;
-export type SupportedOperators = ClosedEnum<typeof SupportedOperators>;
+export type SupportedOperator = OpenEnum<typeof SupportedOperator>;
 
 export type BaseFieldDefinition = {
   name: string;
   label: string;
-  type: BaseFieldDefinitionType;
+  type: TypeEnum;
   group?: string | null | undefined;
-  supportedOperators: Array<SupportedOperators>;
+  supportedOperators: Array<SupportedOperator>;
 };
 
 /** @internal */
-export const BaseFieldDefinitionType$inboundSchema: z.ZodNativeEnum<
-  typeof BaseFieldDefinitionType
-> = z.nativeEnum(BaseFieldDefinitionType);
+export const TypeEnum$inboundSchema: z.ZodType<TypeEnum, unknown> = openEnums
+  .inboundSchema(TypeEnum);
 
 /** @internal */
-export const SupportedOperators$inboundSchema: z.ZodNativeEnum<
-  typeof SupportedOperators
-> = z.nativeEnum(SupportedOperators);
+export const SupportedOperator$inboundSchema: z.ZodType<
+  SupportedOperator,
+  unknown
+> = openEnums.inboundSchema(SupportedOperator);
 
 /** @internal */
 export const BaseFieldDefinition$inboundSchema: z.ZodType<
   BaseFieldDefinition,
-  z.ZodTypeDef,
   unknown
 > = z.object({
   name: z.string(),
   label: z.string(),
-  type: BaseFieldDefinitionType$inboundSchema,
+  type: TypeEnum$inboundSchema,
   group: z.nullable(z.string()).optional(),
-  supported_operators: z.array(SupportedOperators$inboundSchema),
+  supported_operators: z.array(SupportedOperator$inboundSchema),
 }).transform((v) => {
   return remap$(v, {
     "supported_operators": "supportedOperators",

package/src/models/components/basemodelcard.ts

@@ -3,7 +3,7 @@
  * @generated-id: 6e93495032d1
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
@@ -15,49 +15,52 @@ import {
 
 export type BaseModelCard = {
   id: string;
-  object: string | undefined;
+  object: string;
   created?: number | undefined;
-  ownedBy: string | undefined;
+  ownedBy: string;
+  /**
+   * This is populated by Harmattan, but some fields have a name
+   *
+   * @remarks
+   * that we don't want to expose in the API.
+   */
   capabilities: ModelCapabilities;
   name?: string | null | undefined;
   description?: string | null | undefined;
-  maxContextLength: number | undefined;
+  maxContextLength: number;
   aliases?: Array<string> | undefined;
   deprecation?: Date | null | undefined;
   deprecationReplacementModel?: string | null | undefined;
   defaultModelTemperature?: number | null | undefined;
-  type?: "base" | undefined;
+  type: "base";
 };
 
 /** @internal */
-export const BaseModelCard$inboundSchema: z.ZodType<
-  BaseModelCard,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  id: z.string(),
-  object: z.string().default("model"),
-  created: z.number().int().optional(),
-  owned_by: z.string().default("mistralai"),
-  capabilities: ModelCapabilities$inboundSchema,
-  name: z.nullable(z.string()).optional(),
-  description: z.nullable(z.string()).optional(),
-  max_context_length: z.number().int().default(32768),
-  aliases: z.array(z.string()).optional(),
-  deprecation: z.nullable(
-    z.string().datetime({ offset: true }).transform(v => new Date(v)),
-  ).optional(),
-  deprecation_replacement_model: z.nullable(z.string()).optional(),
-  default_model_temperature: z.nullable(z.number()).optional(),
-  type: z.literal("base").default("base"),
-}).transform((v) => {
-  return remap$(v, {
-    "owned_by": "ownedBy",
-    "max_context_length": "maxContextLength",
-    "deprecation_replacement_model": "deprecationReplacementModel",
-    "default_model_temperature": "defaultModelTemperature",
+export const BaseModelCard$inboundSchema: z.ZodType<BaseModelCard, unknown> = z
+  .object({
+    id: z.string(),
+    object: z.string().default("model"),
+    created: z.int().optional(),
+    owned_by: z.string().default("mistralai"),
+    capabilities: ModelCapabilities$inboundSchema,
+    name: z.nullable(z.string()).optional(),
+    description: z.nullable(z.string()).optional(),
+    max_context_length: z.int().default(32768),
+    aliases: z.array(z.string()).optional(),
+    deprecation: z.nullable(
+      z.iso.datetime({ offset: true }).transform(v => new Date(v)),
+    ).optional(),
+    deprecation_replacement_model: z.nullable(z.string()).optional(),
+    default_model_temperature: z.nullable(z.number()).optional(),
+    type: z.literal("base"),
+  }).transform((v) => {
+    return remap$(v, {
+      "owned_by": "ownedBy",
+      "max_context_length": "maxContextLength",
+      "deprecation_replacement_model": "deprecationReplacementModel",
+      "default_model_temperature": "defaultModelTemperature",
+    });
   });
-});
 
 export function baseModelCardFromJSON(
   jsonString: string,

package/src/models/components/basetaskstatus.ts

@@ -3,8 +3,9 @@
  * @generated-id: 6f811821efbc
  */
 
-import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as z from "zod/v4";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const BaseTaskStatus = {
   Running: "RUNNING",
@@ -16,9 +17,8 @@ export const BaseTaskStatus = {
   TimedOut: "TIMED_OUT",
   Unknown: "UNKNOWN",
 } as const;
-export type BaseTaskStatus = ClosedEnum<typeof BaseTaskStatus>;
+export type BaseTaskStatus = OpenEnum<typeof BaseTaskStatus>;
 
 /** @internal */
-export const BaseTaskStatus$inboundSchema: z.ZodNativeEnum<
-  typeof BaseTaskStatus
-> = z.nativeEnum(BaseTaskStatus);
+export const BaseTaskStatus$inboundSchema: z.ZodType<BaseTaskStatus, unknown> =
+  openEnums.inboundSchema(BaseTaskStatus);

package/src/models/components/batcherror.ts

@@ -3,25 +3,22 @@
  * @generated-id: ffe93fb903c6
  */
 
-import * as z from "zod/v3";
+import * as z from "zod/v4";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export type BatchError = {
   message: string;
-  count: number | undefined;
+  count: number;
 };
 
 /** @internal */
-export const BatchError$inboundSchema: z.ZodType<
-  BatchError,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  message: z.string(),
-  count: z.number().int().default(1),
-});
+export const BatchError$inboundSchema: z.ZodType<BatchError, unknown> = z
+  .object({
+    message: z.string(),
+    count: z.int().default(1),
+  });
 
 export function batchErrorFromJSON(
   jsonString: string,

package/src/models/components/batchjob.ts

@@ -0,0 +1,84 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 55e2c042837a
+ */
+
+import * as z from "zod/v4";
+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 { BatchError, BatchError$inboundSchema } from "./batcherror.js";
+import {
+  BatchJobStatus,
+  BatchJobStatus$inboundSchema,
+} from "./batchjobstatus.js";
+
+export type BatchJob = {
+  id: string;
+  object: "batch";
+  inputFiles: Array<string>;
+  metadata?: { [k: string]: any } | null | undefined;
+  endpoint: string;
+  model?: string | null | undefined;
+  agentId?: string | null | undefined;
+  outputFile?: string | null | undefined;
+  errorFile?: string | null | undefined;
+  errors: Array<BatchError>;
+  outputs?: Array<{ [k: string]: any }> | null | undefined;
+  status: BatchJobStatus;
+  createdAt: number;
+  totalRequests: number;
+  completedRequests: number;
+  succeededRequests: number;
+  failedRequests: number;
+  startedAt?: number | null | undefined;
+  completedAt?: number | null | undefined;
+};
+
+/** @internal */
+export const BatchJob$inboundSchema: z.ZodType<BatchJob, unknown> = z.object({
+  id: z.string(),
+  object: z.literal("batch").default("batch"),
+  input_files: z.array(z.string()),
+  metadata: z.nullable(z.record(z.string(), z.any())).optional(),
+  endpoint: z.string(),
+  model: z.nullable(z.string()).optional(),
+  agent_id: z.nullable(z.string()).optional(),
+  output_file: z.nullable(z.string()).optional(),
+  error_file: z.nullable(z.string()).optional(),
+  errors: z.array(BatchError$inboundSchema),
+  outputs: z.nullable(z.array(z.record(z.string(), z.any()))).optional(),
+  status: BatchJobStatus$inboundSchema,
+  created_at: z.int(),
+  total_requests: z.int(),
+  completed_requests: z.int(),
+  succeeded_requests: z.int(),
+  failed_requests: z.int(),
+  started_at: z.nullable(z.int()).optional(),
+  completed_at: z.nullable(z.int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "input_files": "inputFiles",
+    "agent_id": "agentId",
+    "output_file": "outputFile",
+    "error_file": "errorFile",
+    "created_at": "createdAt",
+    "total_requests": "totalRequests",
+    "completed_requests": "completedRequests",
+    "succeeded_requests": "succeededRequests",
+    "failed_requests": "failedRequests",
+    "started_at": "startedAt",
+    "completed_at": "completedAt",
+  });
+});
+
+export function batchJobFromJSON(
+  jsonString: string,
+): SafeParseResult<BatchJob, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BatchJob$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BatchJob' from JSON`,
+  );
+}

package/src/models/components/batchjobstatus.ts

@@ -3,8 +3,9 @@
  * @generated-id: 3df94bfaf195
  */
 
-import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
+import * as z from "zod/v4";
+import * as openEnums from "../../types/enums.js";
+import { OpenEnum } from "../../types/enums.js";
 
 export const BatchJobStatus = {
   Queued: "QUEUED",
@@ -15,13 +16,11 @@ export const BatchJobStatus = {
   CancellationRequested: "CANCELLATION_REQUESTED",
   Cancelled: "CANCELLED",
 } as const;
-export type BatchJobStatus = ClosedEnum<typeof BatchJobStatus>;
+export type BatchJobStatus = OpenEnum<typeof BatchJobStatus>;
 
 /** @internal */
-export const BatchJobStatus$inboundSchema: z.ZodNativeEnum<
-  typeof BatchJobStatus
-> = z.nativeEnum(BatchJobStatus);
+export const BatchJobStatus$inboundSchema: z.ZodType<BatchJobStatus, unknown> =
+  openEnums.inboundSchema(BatchJobStatus);
 /** @internal */
-export const BatchJobStatus$outboundSchema: z.ZodNativeEnum<
-  typeof BatchJobStatus
-> = BatchJobStatus$inboundSchema;
+export const BatchJobStatus$outboundSchema: z.ZodType<string, BatchJobStatus> =
+  openEnums.outboundSchema(BatchJobStatus);