@mistralai/mistralai 1.13.0 → 1.14.1

package/src/models/components/transcriptionstreamlanguage.ts

@@ -8,32 +8,15 @@ import {
   collectExtraKeys as collectExtraKeys$,
   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 TranscriptionStreamLanguageType = {
-  TranscriptionLanguage: "transcription.language",
-} as const;
-export type TranscriptionStreamLanguageType = ClosedEnum<
-  typeof TranscriptionStreamLanguageType
->;
-
 export type TranscriptionStreamLanguage = {
-  type?: TranscriptionStreamLanguageType | undefined;
+  type?: "transcription.language" | undefined;
   audioLanguage: string;
   additionalProperties?: { [k: string]: any } | undefined;
 };
 
-/** @internal */
-export const TranscriptionStreamLanguageType$inboundSchema: z.ZodNativeEnum<
-  typeof TranscriptionStreamLanguageType
-> = z.nativeEnum(TranscriptionStreamLanguageType);
-/** @internal */
-export const TranscriptionStreamLanguageType$outboundSchema: z.ZodNativeEnum<
-  typeof TranscriptionStreamLanguageType
-> = TranscriptionStreamLanguageType$inboundSchema;
-
 /** @internal */
 export const TranscriptionStreamLanguage$inboundSchema: z.ZodType<
   TranscriptionStreamLanguage,
@@ -41,9 +24,7 @@ export const TranscriptionStreamLanguage$inboundSchema: z.ZodType<
   unknown
 > = collectExtraKeys$(
   z.object({
-    type: TranscriptionStreamLanguageType$inboundSchema.default(
-      "transcription.language",
-    ),
+    type: z.literal("transcription.language").default("transcription.language"),
     audio_language: z.string(),
   }).catchall(z.any()),
   "additionalProperties",
@@ -55,7 +36,7 @@ export const TranscriptionStreamLanguage$inboundSchema: z.ZodType<
 });
 /** @internal */
 export type TranscriptionStreamLanguage$Outbound = {
-  type: string;
+  type: "transcription.language";
   audio_language: string;
   [additionalProperties: string]: unknown;
 };
@@ -66,8 +47,8 @@ export const TranscriptionStreamLanguage$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   TranscriptionStreamLanguage
 > = z.object({
-  type: TranscriptionStreamLanguageType$outboundSchema.default(
-    "transcription.language",
+  type: z.literal("transcription.language").default(
+    "transcription.language" as const,
   ),
   audioLanguage: z.string(),
   additionalProperties: z.record(z.any()).optional(),

package/src/models/components/transcriptionstreamsegmentdelta.ts

@@ -3,34 +3,23 @@
  */
 
 import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
 import {
   collectExtraKeys as collectExtraKeys$,
   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 TranscriptionStreamSegmentDeltaType = {
-  TranscriptionSegment: "transcription.segment",
-} as const;
-export type TranscriptionStreamSegmentDeltaType = ClosedEnum<
-  typeof TranscriptionStreamSegmentDeltaType
->;
-
 export type TranscriptionStreamSegmentDelta = {
+  type?: "transcription.segment" | undefined;
   text: string;
   start: number;
   end: number;
-  type: TranscriptionStreamSegmentDeltaType | undefined;
+  speakerId?: string | null | undefined;
   additionalProperties?: { [k: string]: any } | undefined;
 };
 
-/** @internal */
-export const TranscriptionStreamSegmentDeltaType$inboundSchema: z.ZodNativeEnum<
-  typeof TranscriptionStreamSegmentDeltaType
-> = z.nativeEnum(TranscriptionStreamSegmentDeltaType);
-
 /** @internal */
 export const TranscriptionStreamSegmentDelta$inboundSchema: z.ZodType<
   TranscriptionStreamSegmentDelta,
@@ -38,16 +27,19 @@ export const TranscriptionStreamSegmentDelta$inboundSchema: z.ZodType<
   unknown
 > = collectExtraKeys$(
   z.object({
+    type: z.literal("transcription.segment").default("transcription.segment"),
     text: z.string(),
     start: z.number(),
     end: z.number(),
-    type: TranscriptionStreamSegmentDeltaType$inboundSchema.default(
-      "transcription.segment",
-    ),
+    speaker_id: z.nullable(z.string()).optional(),
   }).catchall(z.any()),
   "additionalProperties",
   true,
-);
+).transform((v) => {
+  return remap$(v, {
+    "speaker_id": "speakerId",
+  });
+});
 
 export function transcriptionStreamSegmentDeltaFromJSON(
   jsonString: string,

package/src/models/components/transcriptionstreamtextdelta.ts

@@ -8,32 +8,15 @@ import {
   collectExtraKeys as collectExtraKeys$,
   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 TranscriptionStreamTextDeltaType = {
-  TranscriptionTextDelta: "transcription.text.delta",
-} as const;
-export type TranscriptionStreamTextDeltaType = ClosedEnum<
-  typeof TranscriptionStreamTextDeltaType
->;
-
 export type TranscriptionStreamTextDelta = {
+  type?: "transcription.text.delta" | undefined;
   text: string;
-  type?: TranscriptionStreamTextDeltaType | undefined;
   additionalProperties?: { [k: string]: any } | undefined;
 };
 
-/** @internal */
-export const TranscriptionStreamTextDeltaType$inboundSchema: z.ZodNativeEnum<
-  typeof TranscriptionStreamTextDeltaType
-> = z.nativeEnum(TranscriptionStreamTextDeltaType);
-/** @internal */
-export const TranscriptionStreamTextDeltaType$outboundSchema: z.ZodNativeEnum<
-  typeof TranscriptionStreamTextDeltaType
-> = TranscriptionStreamTextDeltaType$inboundSchema;
-
 /** @internal */
 export const TranscriptionStreamTextDelta$inboundSchema: z.ZodType<
   TranscriptionStreamTextDelta,
@@ -41,18 +24,18 @@ export const TranscriptionStreamTextDelta$inboundSchema: z.ZodType<
   unknown
 > = collectExtraKeys$(
   z.object({
-    text: z.string(),
-    type: TranscriptionStreamTextDeltaType$inboundSchema.default(
+    type: z.literal("transcription.text.delta").default(
       "transcription.text.delta",
     ),
+    text: z.string(),
   }).catchall(z.any()),
   "additionalProperties",
   true,
 );
 /** @internal */
 export type TranscriptionStreamTextDelta$Outbound = {
+  type: "transcription.text.delta";
   text: string;
-  type: string;
   [additionalProperties: string]: unknown;
 };
 
@@ -62,10 +45,10 @@ export const TranscriptionStreamTextDelta$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   TranscriptionStreamTextDelta
 > = z.object({
-  text: z.string(),
-  type: TranscriptionStreamTextDeltaType$outboundSchema.default(
-    "transcription.text.delta",
+  type: z.literal("transcription.text.delta").default(
+    "transcription.text.delta" as const,
   ),
+  text: z.string(),
   additionalProperties: z.record(z.any()).optional(),
 }).transform((v) => {
   return {

package/src/models/components/unarchiveftmodelout.ts

@@ -4,28 +4,15 @@
 
 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 UnarchiveFTModelOutObject = {
-  Model: "model",
-} as const;
-export type UnarchiveFTModelOutObject = ClosedEnum<
-  typeof UnarchiveFTModelOutObject
->;
-
 export type UnarchiveFTModelOut = {
   id: string;
-  object: UnarchiveFTModelOutObject | undefined;
+  object?: "model" | undefined;
   archived: boolean | undefined;
 };
 
-/** @internal */
-export const UnarchiveFTModelOutObject$inboundSchema: z.ZodNativeEnum<
-  typeof UnarchiveFTModelOutObject
-> = z.nativeEnum(UnarchiveFTModelOutObject);
-
 /** @internal */
 export const UnarchiveFTModelOut$inboundSchema: z.ZodType<
   UnarchiveFTModelOut,
@@ -33,7 +20,7 @@ export const UnarchiveFTModelOut$inboundSchema: z.ZodType<
   unknown
 > = z.object({
   id: z.string(),
-  object: UnarchiveFTModelOutObject$inboundSchema.default("model"),
+  object: z.literal("model").default("model"),
   archived: z.boolean().default(false),
 });
 

package/src/models/components/usermessage.ts

@@ -3,7 +3,6 @@
  */
 
 import * as z from "zod/v3";
-import { ClosedEnum } from "../../types/enums.js";
 import {
   ContentChunk,
   ContentChunk$Outbound,
@@ -12,14 +11,9 @@ import {
 
 export type UserMessageContent = string | Array<ContentChunk>;
 
-export const UserMessageRole = {
-  User: "user",
-} as const;
-export type UserMessageRole = ClosedEnum<typeof UserMessageRole>;
-
 export type UserMessage = {
+  role?: "user" | undefined;
   content: string | Array<ContentChunk> | null;
-  role?: UserMessageRole | undefined;
 };
 
 /** @internal */
@@ -40,15 +34,10 @@ export function userMessageContentToJSON(
   );
 }
 
-/** @internal */
-export const UserMessageRole$outboundSchema: z.ZodNativeEnum<
-  typeof UserMessageRole
-> = z.nativeEnum(UserMessageRole);
-
 /** @internal */
 export type UserMessage$Outbound = {
+  role: "user";
   content: string | Array<ContentChunk$Outbound> | null;
-  role: string;
 };
 
 /** @internal */
@@ -57,10 +46,10 @@ export const UserMessage$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   UserMessage
 > = z.object({
+  role: z.literal("user").default("user" as const),
   content: z.nullable(
     z.union([z.string(), z.array(ContentChunk$outboundSchema)]),
   ),
-  role: UserMessageRole$outboundSchema.default("user"),
 });
 
 export function userMessageToJSON(userMessage: UserMessage): string {

package/src/models/components/wandbintegration.ts

@@ -4,15 +4,9 @@
 
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
-import { ClosedEnum } from "../../types/enums.js";
-
-export const WandbIntegrationType = {
-  Wandb: "wandb",
-} as const;
-export type WandbIntegrationType = ClosedEnum<typeof WandbIntegrationType>;
 
 export type WandbIntegration = {
-  type?: WandbIntegrationType | undefined;
+  type?: "wandb" | undefined;
   /**
    * The name of the project that the new run will be created under.
    */
@@ -28,14 +22,9 @@ export type WandbIntegration = {
   runName?: string | null | undefined;
 };
 
-/** @internal */
-export const WandbIntegrationType$outboundSchema: z.ZodNativeEnum<
-  typeof WandbIntegrationType
-> = z.nativeEnum(WandbIntegrationType);
-
 /** @internal */
 export type WandbIntegration$Outbound = {
-  type: string;
+  type: "wandb";
   project: string;
   name?: string | null | undefined;
   api_key: string;
@@ -48,7 +37,7 @@ export const WandbIntegration$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   WandbIntegration
 > = z.object({
-  type: WandbIntegrationType$outboundSchema.default("wandb"),
+  type: z.literal("wandb").default("wandb" as const),
   project: z.string(),
   name: z.nullable(z.string()).optional(),
   apiKey: z.string(),

package/src/models/components/wandbintegrationout.ts

@@ -5,19 +5,11 @@
 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 WandbIntegrationOutType = {
-  Wandb: "wandb",
-} as const;
-export type WandbIntegrationOutType = ClosedEnum<
-  typeof WandbIntegrationOutType
->;
-
 export type WandbIntegrationOut = {
-  type: WandbIntegrationOutType | undefined;
+  type?: "wandb" | undefined;
   /**
    * The name of the project that the new run will be created under.
    */
@@ -30,18 +22,13 @@ export type WandbIntegrationOut = {
   url?: string | null | undefined;
 };
 
-/** @internal */
-export const WandbIntegrationOutType$inboundSchema: z.ZodNativeEnum<
-  typeof WandbIntegrationOutType
-> = z.nativeEnum(WandbIntegrationOutType);
-
 /** @internal */
 export const WandbIntegrationOut$inboundSchema: z.ZodType<
   WandbIntegrationOut,
   z.ZodTypeDef,
   unknown
 > = z.object({
-  type: WandbIntegrationOutType$inboundSchema.default("wandb"),
+  type: z.literal("wandb").default("wandb"),
   project: z.string(),
   name: z.nullable(z.string()).optional(),
   run_name: z.nullable(z.string()).optional(),

package/src/models/components/websearchpremiumtool.ts

@@ -3,10 +3,17 @@
  */
 
 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 {
+  ToolConfiguration,
+  ToolConfiguration$inboundSchema,
+  ToolConfiguration$Outbound,
+  ToolConfiguration$outboundSchema,
+} from "./toolconfiguration.js";
 
 export const WebSearchPremiumToolType = {
   WebSearchPremium: "web_search_premium",
@@ -16,6 +23,7 @@ export type WebSearchPremiumToolType = ClosedEnum<
 >;
 
 export type WebSearchPremiumTool = {
+  toolConfiguration?: ToolConfiguration | null | undefined;
   type?: WebSearchPremiumToolType | undefined;
 };
 
@@ -34,10 +42,16 @@ export const WebSearchPremiumTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  tool_configuration: z.nullable(ToolConfiguration$inboundSchema).optional(),
   type: WebSearchPremiumToolType$inboundSchema.default("web_search_premium"),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_configuration": "toolConfiguration",
+  });
 });
 /** @internal */
 export type WebSearchPremiumTool$Outbound = {
+  tool_configuration?: ToolConfiguration$Outbound | null | undefined;
   type: string;
 };
 
@@ -47,7 +61,12 @@ export const WebSearchPremiumTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   WebSearchPremiumTool
 > = z.object({
+  toolConfiguration: z.nullable(ToolConfiguration$outboundSchema).optional(),
   type: WebSearchPremiumToolType$outboundSchema.default("web_search_premium"),
+}).transform((v) => {
+  return remap$(v, {
+    toolConfiguration: "tool_configuration",
+  });
 });
 
 export function webSearchPremiumToolToJSON(

package/src/models/components/websearchtool.ts

@@ -3,10 +3,17 @@
  */
 
 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 {
+  ToolConfiguration,
+  ToolConfiguration$inboundSchema,
+  ToolConfiguration$Outbound,
+  ToolConfiguration$outboundSchema,
+} from "./toolconfiguration.js";
 
 export const WebSearchToolType = {
   WebSearch: "web_search",
@@ -14,6 +21,7 @@ export const WebSearchToolType = {
 export type WebSearchToolType = ClosedEnum<typeof WebSearchToolType>;
 
 export type WebSearchTool = {
+  toolConfiguration?: ToolConfiguration | null | undefined;
   type?: WebSearchToolType | undefined;
 };
 
@@ -32,10 +40,16 @@ export const WebSearchTool$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  tool_configuration: z.nullable(ToolConfiguration$inboundSchema).optional(),
   type: WebSearchToolType$inboundSchema.default("web_search"),
+}).transform((v) => {
+  return remap$(v, {
+    "tool_configuration": "toolConfiguration",
+  });
 });
 /** @internal */
 export type WebSearchTool$Outbound = {
+  tool_configuration?: ToolConfiguration$Outbound | null | undefined;
   type: string;
 };
 
@@ -45,7 +59,12 @@ export const WebSearchTool$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   WebSearchTool
 > = z.object({
+  toolConfiguration: z.nullable(ToolConfiguration$outboundSchema).optional(),
   type: WebSearchToolType$outboundSchema.default("web_search"),
+}).transform((v) => {
+  return remap$(v, {
+    toolConfiguration: "tool_configuration",
+  });
 });
 
 export function webSearchToolToJSON(webSearchTool: WebSearchTool): string {

package/src/models/operations/agentsapiv1agentscreateorupdatealias.ts

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type AgentsApiV1AgentsCreateOrUpdateAliasRequest = {
+  agentId: string;
+  alias: string;
+  version: number;
+};
+
+/** @internal */
+export type AgentsApiV1AgentsCreateOrUpdateAliasRequest$Outbound = {
+  agent_id: string;
+  alias: string;
+  version: number;
+};
+
+/** @internal */
+export const AgentsApiV1AgentsCreateOrUpdateAliasRequest$outboundSchema:
+  z.ZodType<
+    AgentsApiV1AgentsCreateOrUpdateAliasRequest$Outbound,
+    z.ZodTypeDef,
+    AgentsApiV1AgentsCreateOrUpdateAliasRequest
+  > = z.object({
+    agentId: z.string(),
+    alias: z.string(),
+    version: z.number().int(),
+  }).transform((v) => {
+    return remap$(v, {
+      agentId: "agent_id",
+    });
+  });
+
+export function agentsApiV1AgentsCreateOrUpdateAliasRequestToJSON(
+  agentsApiV1AgentsCreateOrUpdateAliasRequest:
+    AgentsApiV1AgentsCreateOrUpdateAliasRequest,
+): string {
+  return JSON.stringify(
+    AgentsApiV1AgentsCreateOrUpdateAliasRequest$outboundSchema.parse(
+      agentsApiV1AgentsCreateOrUpdateAliasRequest,
+    ),
+  );
+}

package/src/models/operations/agentsapiv1agentsdeletealias.ts

@@ -0,0 +1,41 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+
+export type AgentsApiV1AgentsDeleteAliasRequest = {
+  agentId: string;
+  alias: string;
+};
+
+/** @internal */
+export type AgentsApiV1AgentsDeleteAliasRequest$Outbound = {
+  agent_id: string;
+  alias: string;
+};
+
+/** @internal */
+export const AgentsApiV1AgentsDeleteAliasRequest$outboundSchema: z.ZodType<
+  AgentsApiV1AgentsDeleteAliasRequest$Outbound,
+  z.ZodTypeDef,
+  AgentsApiV1AgentsDeleteAliasRequest
+> = z.object({
+  agentId: z.string(),
+  alias: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    agentId: "agent_id",
+  });
+});
+
+export function agentsApiV1AgentsDeleteAliasRequestToJSON(
+  agentsApiV1AgentsDeleteAliasRequest: AgentsApiV1AgentsDeleteAliasRequest,
+): string {
+  return JSON.stringify(
+    AgentsApiV1AgentsDeleteAliasRequest$outboundSchema.parse(
+      agentsApiV1AgentsDeleteAliasRequest,
+    ),
+  );
+}

package/src/models/operations/agentsapiv1agentsget.ts

@@ -5,15 +5,31 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 
+export type AgentVersion = number | string;
+
 export type AgentsApiV1AgentsGetRequest = {
   agentId: string;
-  agentVersion?: number | null | undefined;
+  agentVersion?: number | string | null | undefined;
 };
 
+/** @internal */
+export type AgentVersion$Outbound = number | string;
+
+/** @internal */
+export const AgentVersion$outboundSchema: z.ZodType<
+  AgentVersion$Outbound,
+  z.ZodTypeDef,
+  AgentVersion
+> = z.union([z.number().int(), z.string()]);
+
+export function agentVersionToJSON(agentVersion: AgentVersion): string {
+  return JSON.stringify(AgentVersion$outboundSchema.parse(agentVersion));
+}
+
 /** @internal */
 export type AgentsApiV1AgentsGetRequest$Outbound = {
   agent_id: string;
-  agent_version?: number | null | undefined;
+  agent_version?: number | string | null | undefined;
 };
 
 /** @internal */
@@ -23,7 +39,7 @@ export const AgentsApiV1AgentsGetRequest$outboundSchema: z.ZodType<
   AgentsApiV1AgentsGetRequest
 > = z.object({
   agentId: z.string(),
-  agentVersion: z.nullable(z.number().int()).optional(),
+  agentVersion: z.nullable(z.union([z.number().int(), z.string()])).optional(),
 }).transform((v) => {
   return remap$(v, {
     agentId: "agent_id",

package/src/models/operations/agentsapiv1agentsgetversion.ts

@@ -7,13 +7,13 @@ import { remap as remap$ } from "../../lib/primitives.js";
 
 export type AgentsApiV1AgentsGetVersionRequest = {
   agentId: string;
-  version: number;
+  version: string;
 };
 
 /** @internal */
 export type AgentsApiV1AgentsGetVersionRequest$Outbound = {
   agent_id: string;
-  version: number;
+  version: string;
 };
 
 /** @internal */
@@ -23,7 +23,7 @@ export const AgentsApiV1AgentsGetVersionRequest$outboundSchema: z.ZodType<
   AgentsApiV1AgentsGetVersionRequest
 > = z.object({
   agentId: z.string(),
-  version: z.number().int(),
+  version: z.string(),
 }).transform((v) => {
   return remap$(v, {
     agentId: "agent_id",

package/src/models/operations/agentsapiv1agentslist.ts

@@ -17,7 +17,14 @@ export type AgentsApiV1AgentsListRequest = {
   pageSize?: number | undefined;
   deploymentChat?: boolean | null | undefined;
   sources?: Array<components.RequestSource> | null | undefined;
+  /**
+   * Filter by agent name
+   */
   name?: string | null | undefined;
+  /**
+   * Search agents by name or ID
+   */
+  search?: string | null | undefined;
   id?: string | null | undefined;
   metadata?: { [k: string]: any } | null | undefined;
 };
@@ -29,6 +36,7 @@ export type AgentsApiV1AgentsListRequest$Outbound = {
   deployment_chat?: boolean | null | undefined;
   sources?: Array<string> | null | undefined;
   name?: string | null | undefined;
+  search?: string | null | undefined;
   id?: string | null | undefined;
   metadata?: { [k: string]: any } | null | undefined;
 };
@@ -45,6 +53,7 @@ export const AgentsApiV1AgentsListRequest$outboundSchema: z.ZodType<
   sources: z.nullable(z.array(components.RequestSource$outboundSchema))
     .optional(),
   name: z.nullable(z.string()).optional(),
+  search: z.nullable(z.string()).optional(),
   id: z.nullable(z.string()).optional(),
   metadata: z.nullable(z.record(z.any())).optional(),
 }).transform((v) => {