@mistralai/mistralai 1.7.3 → 1.7.4

package/src/models/components/basemodelcard.ts

@@ -5,6 +5,7 @@
 import * as z from "zod";
 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 {
@@ -14,6 +15,11 @@ import {
   ModelCapabilities$outboundSchema,
 } from "./modelcapabilities.js";
 
+export const Type = {
+  Base: "base",
+} as const;
+export type Type = ClosedEnum<typeof Type>;
+
 export type BaseModelCard = {
   id: string;
   object?: string | undefined;
@@ -30,6 +36,26 @@ export type BaseModelCard = {
   type?: "base" | undefined;
 };
 
+/** @internal */
+export const Type$inboundSchema: z.ZodNativeEnum<typeof Type> = z.nativeEnum(
+  Type,
+);
+
+/** @internal */
+export const Type$outboundSchema: z.ZodNativeEnum<typeof Type> =
+  Type$inboundSchema;
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace Type$ {
+  /** @deprecated use `Type$inboundSchema` instead. */
+  export const inboundSchema = Type$inboundSchema;
+  /** @deprecated use `Type$outboundSchema` instead. */
+  export const outboundSchema = Type$outboundSchema;
+}
+
 /** @internal */
 export const BaseModelCard$inboundSchema: z.ZodType<
   BaseModelCard,
@@ -95,7 +121,7 @@ export const BaseModelCard$outboundSchema: z.ZodType<
   deprecation: z.nullable(z.date().transform(v => v.toISOString())).optional(),
   deprecationReplacementModel: z.nullable(z.string()).optional(),
   defaultModelTemperature: z.nullable(z.number()).optional(),
-  type: z.literal("base").default("base" as const),
+  type: z.literal("base").default("base"),
 }).transform((v) => {
   return remap$(v, {
     ownedBy: "owned_by",

package/src/models/components/conversationevents.ts

@@ -53,6 +53,12 @@ import {
   SSETypes$inboundSchema,
   SSETypes$outboundSchema,
 } from "./ssetypes.js";
+import {
+  ToolExecutionDeltaEvent,
+  ToolExecutionDeltaEvent$inboundSchema,
+  ToolExecutionDeltaEvent$Outbound,
+  ToolExecutionDeltaEvent$outboundSchema,
+} from "./toolexecutiondeltaevent.js";
 import {
   ToolExecutionDoneEvent,
   ToolExecutionDoneEvent$inboundSchema,
@@ -70,10 +76,11 @@ export type ConversationEventsData =
   | (ResponseDoneEvent & { type: "conversation.response.done" })
   | (ResponseStartedEvent & { type: "conversation.response.started" })
   | (ResponseErrorEvent & { type: "conversation.response.error" })
-  | (ToolExecutionStartedEvent & { type: "tool.execution.started" })
   | (AgentHandoffDoneEvent & { type: "agent.handoff.done" })
   | (AgentHandoffStartedEvent & { type: "agent.handoff.started" })
+  | (ToolExecutionDeltaEvent & { type: "tool.execution.delta" })
   | (ToolExecutionDoneEvent & { type: "tool.execution.done" })
+  | (ToolExecutionStartedEvent & { type: "tool.execution.started" })
   | (FunctionCallEvent & { type: "function.call.delta" })
   | (MessageOutputEvent & { type: "message.output.delta" });
 
@@ -86,10 +93,11 @@ export type ConversationEvents = {
     | (ResponseDoneEvent & { type: "conversation.response.done" })
     | (ResponseStartedEvent & { type: "conversation.response.started" })
     | (ResponseErrorEvent & { type: "conversation.response.error" })
-    | (ToolExecutionStartedEvent & { type: "tool.execution.started" })
     | (AgentHandoffDoneEvent & { type: "agent.handoff.done" })
     | (AgentHandoffStartedEvent & { type: "agent.handoff.started" })
+    | (ToolExecutionDeltaEvent & { type: "tool.execution.delta" })
     | (ToolExecutionDoneEvent & { type: "tool.execution.done" })
+    | (ToolExecutionStartedEvent & { type: "tool.execution.started" })
     | (FunctionCallEvent & { type: "function.call.delta" })
     | (MessageOutputEvent & { type: "message.output.delta" });
 };
@@ -115,11 +123,6 @@ export const ConversationEventsData$inboundSchema: z.ZodType<
       v,
     ) => ({ type: v.type })),
   ),
-  ToolExecutionStartedEvent$inboundSchema.and(
-    z.object({ type: z.literal("tool.execution.started") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
   AgentHandoffDoneEvent$inboundSchema.and(
     z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
       type: v.type,
@@ -130,11 +133,21 @@ export const ConversationEventsData$inboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
+  ToolExecutionDeltaEvent$inboundSchema.and(
+    z.object({ type: z.literal("tool.execution.delta") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
   ToolExecutionDoneEvent$inboundSchema.and(
     z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
       type: v.type,
     })),
   ),
+  ToolExecutionStartedEvent$inboundSchema.and(
+    z.object({ type: z.literal("tool.execution.started") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
   FunctionCallEvent$inboundSchema.and(
     z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
       type: v.type,
@@ -152,10 +165,11 @@ export type ConversationEventsData$Outbound =
   | (ResponseDoneEvent$Outbound & { type: "conversation.response.done" })
   | (ResponseStartedEvent$Outbound & { type: "conversation.response.started" })
   | (ResponseErrorEvent$Outbound & { type: "conversation.response.error" })
-  | (ToolExecutionStartedEvent$Outbound & { type: "tool.execution.started" })
   | (AgentHandoffDoneEvent$Outbound & { type: "agent.handoff.done" })
   | (AgentHandoffStartedEvent$Outbound & { type: "agent.handoff.started" })
+  | (ToolExecutionDeltaEvent$Outbound & { type: "tool.execution.delta" })
   | (ToolExecutionDoneEvent$Outbound & { type: "tool.execution.done" })
+  | (ToolExecutionStartedEvent$Outbound & { type: "tool.execution.started" })
   | (FunctionCallEvent$Outbound & { type: "function.call.delta" })
   | (MessageOutputEvent$Outbound & { type: "message.output.delta" });
 
@@ -180,11 +194,6 @@ export const ConversationEventsData$outboundSchema: z.ZodType<
       v,
     ) => ({ type: v.type })),
   ),
-  ToolExecutionStartedEvent$outboundSchema.and(
-    z.object({ type: z.literal("tool.execution.started") }).transform((v) => ({
-      type: v.type,
-    })),
-  ),
   AgentHandoffDoneEvent$outboundSchema.and(
     z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
       type: v.type,
@@ -195,11 +204,21 @@ export const ConversationEventsData$outboundSchema: z.ZodType<
       type: v.type,
     })),
   ),
+  ToolExecutionDeltaEvent$outboundSchema.and(
+    z.object({ type: z.literal("tool.execution.delta") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
   ToolExecutionDoneEvent$outboundSchema.and(
     z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
       type: v.type,
     })),
   ),
+  ToolExecutionStartedEvent$outboundSchema.and(
+    z.object({ type: z.literal("tool.execution.started") }).transform((v) => ({
+      type: v.type,
+    })),
+  ),
   FunctionCallEvent$outboundSchema.and(
     z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
       type: v.type,
@@ -276,11 +295,6 @@ export const ConversationEvents$inboundSchema: z.ZodType<
           v,
         ) => ({ type: v.type })),
       ),
-      ToolExecutionStartedEvent$inboundSchema.and(
-        z.object({ type: z.literal("tool.execution.started") }).transform((
-          v,
-        ) => ({ type: v.type })),
-      ),
       AgentHandoffDoneEvent$inboundSchema.and(
         z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
           type: v.type,
@@ -291,11 +305,21 @@ export const ConversationEvents$inboundSchema: z.ZodType<
           v,
         ) => ({ type: v.type })),
       ),
+      ToolExecutionDeltaEvent$inboundSchema.and(
+        z.object({ type: z.literal("tool.execution.delta") }).transform((
+          v,
+        ) => ({ type: v.type })),
+      ),
       ToolExecutionDoneEvent$inboundSchema.and(
         z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
           type: v.type,
         })),
       ),
+      ToolExecutionStartedEvent$inboundSchema.and(
+        z.object({ type: z.literal("tool.execution.started") }).transform((
+          v,
+        ) => ({ type: v.type })),
+      ),
       FunctionCallEvent$inboundSchema.and(
         z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
           type: v.type,
@@ -319,10 +343,11 @@ export type ConversationEvents$Outbound = {
       type: "conversation.response.started";
     })
     | (ResponseErrorEvent$Outbound & { type: "conversation.response.error" })
-    | (ToolExecutionStartedEvent$Outbound & { type: "tool.execution.started" })
     | (AgentHandoffDoneEvent$Outbound & { type: "agent.handoff.done" })
     | (AgentHandoffStartedEvent$Outbound & { type: "agent.handoff.started" })
+    | (ToolExecutionDeltaEvent$Outbound & { type: "tool.execution.delta" })
     | (ToolExecutionDoneEvent$Outbound & { type: "tool.execution.done" })
+    | (ToolExecutionStartedEvent$Outbound & { type: "tool.execution.started" })
     | (FunctionCallEvent$Outbound & { type: "function.call.delta" })
     | (MessageOutputEvent$Outbound & { type: "message.output.delta" });
 };
@@ -350,11 +375,6 @@ export const ConversationEvents$outboundSchema: z.ZodType<
         v,
       ) => ({ type: v.type })),
     ),
-    ToolExecutionStartedEvent$outboundSchema.and(
-      z.object({ type: z.literal("tool.execution.started") }).transform((
-        v,
-      ) => ({ type: v.type })),
-    ),
     AgentHandoffDoneEvent$outboundSchema.and(
       z.object({ type: z.literal("agent.handoff.done") }).transform((v) => ({
         type: v.type,
@@ -365,11 +385,21 @@ export const ConversationEvents$outboundSchema: z.ZodType<
         type: v.type,
       })),
     ),
+    ToolExecutionDeltaEvent$outboundSchema.and(
+      z.object({ type: z.literal("tool.execution.delta") }).transform((v) => ({
+        type: v.type,
+      })),
+    ),
     ToolExecutionDoneEvent$outboundSchema.and(
       z.object({ type: z.literal("tool.execution.done") }).transform((v) => ({
         type: v.type,
       })),
     ),
+    ToolExecutionStartedEvent$outboundSchema.and(
+      z.object({ type: z.literal("tool.execution.started") }).transform((
+        v,
+      ) => ({ type: v.type })),
+    ),
     FunctionCallEvent$outboundSchema.and(
       z.object({ type: z.literal("function.call.delta") }).transform((v) => ({
         type: v.type,

package/src/models/components/conversationhistory.ts

@@ -53,10 +53,10 @@ export type ConversationHistoryObject = ClosedEnum<
 >;
 
 export type Entries =
-  | MessageInputEntry
   | FunctionResultEntry
-  | ToolExecutionEntry
+  | MessageInputEntry
   | FunctionCallEntry
+  | ToolExecutionEntry
   | MessageOutputEntry
   | AgentHandoffEntry;
 
@@ -67,10 +67,10 @@ export type ConversationHistory = {
   object?: ConversationHistoryObject | undefined;
   conversationId: string;
   entries: Array<
-    | MessageInputEntry
     | FunctionResultEntry
-    | ToolExecutionEntry
+    | MessageInputEntry
     | FunctionCallEntry
+    | ToolExecutionEntry
     | MessageOutputEntry
     | AgentHandoffEntry
   >;
@@ -100,20 +100,20 @@ export namespace ConversationHistoryObject$ {
 /** @internal */
 export const Entries$inboundSchema: z.ZodType<Entries, z.ZodTypeDef, unknown> =
   z.union([
-    MessageInputEntry$inboundSchema,
     FunctionResultEntry$inboundSchema,
-    ToolExecutionEntry$inboundSchema,
+    MessageInputEntry$inboundSchema,
     FunctionCallEntry$inboundSchema,
+    ToolExecutionEntry$inboundSchema,
     MessageOutputEntry$inboundSchema,
     AgentHandoffEntry$inboundSchema,
   ]);
 
 /** @internal */
 export type Entries$Outbound =
-  | MessageInputEntry$Outbound
   | FunctionResultEntry$Outbound
-  | ToolExecutionEntry$Outbound
+  | MessageInputEntry$Outbound
   | FunctionCallEntry$Outbound
+  | ToolExecutionEntry$Outbound
   | MessageOutputEntry$Outbound
   | AgentHandoffEntry$Outbound;
 
@@ -123,10 +123,10 @@ export const Entries$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   Entries
 > = z.union([
-  MessageInputEntry$outboundSchema,
   FunctionResultEntry$outboundSchema,
-  ToolExecutionEntry$outboundSchema,
+  MessageInputEntry$outboundSchema,
   FunctionCallEntry$outboundSchema,
+  ToolExecutionEntry$outboundSchema,
   MessageOutputEntry$outboundSchema,
   AgentHandoffEntry$outboundSchema,
 ]);
@@ -170,10 +170,10 @@ export const ConversationHistory$inboundSchema: z.ZodType<
   conversation_id: z.string(),
   entries: z.array(
     z.union([
-      MessageInputEntry$inboundSchema,
       FunctionResultEntry$inboundSchema,
-      ToolExecutionEntry$inboundSchema,
+      MessageInputEntry$inboundSchema,
       FunctionCallEntry$inboundSchema,
+      ToolExecutionEntry$inboundSchema,
       MessageOutputEntry$inboundSchema,
       AgentHandoffEntry$inboundSchema,
     ]),
@@ -189,10 +189,10 @@ export type ConversationHistory$Outbound = {
   object: string;
   conversation_id: string;
   entries: Array<
-    | MessageInputEntry$Outbound
     | FunctionResultEntry$Outbound
-    | ToolExecutionEntry$Outbound
+    | MessageInputEntry$Outbound
     | FunctionCallEntry$Outbound
+    | ToolExecutionEntry$Outbound
     | MessageOutputEntry$Outbound
     | AgentHandoffEntry$Outbound
   >;
@@ -210,10 +210,10 @@ export const ConversationHistory$outboundSchema: z.ZodType<
   conversationId: z.string(),
   entries: z.array(
     z.union([
-      MessageInputEntry$outboundSchema,
       FunctionResultEntry$outboundSchema,
-      ToolExecutionEntry$outboundSchema,
+      MessageInputEntry$outboundSchema,
       FunctionCallEntry$outboundSchema,
+      ToolExecutionEntry$outboundSchema,
       MessageOutputEntry$outboundSchema,
       AgentHandoffEntry$outboundSchema,
     ]),

package/src/models/components/documentout.ts

@@ -0,0 +1,158 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+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 DocumentOut = {
+  id: string;
+  libraryId: string;
+  hash: string;
+  mimeType: string;
+  extension: string;
+  size: number;
+  name: string;
+  summary?: string | null | undefined;
+  createdAt: Date;
+  lastProcessedAt?: Date | null | undefined;
+  numberOfPages?: number | null | undefined;
+  processingStatus: string;
+  uploadedById: string;
+  uploadedByType: string;
+  tokensProcessingMainContent?: number | null | undefined;
+  tokensProcessingSummary?: number | null | undefined;
+  tokensProcessingTotal: number;
+};
+
+/** @internal */
+export const DocumentOut$inboundSchema: z.ZodType<
+  DocumentOut,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  library_id: z.string(),
+  hash: z.string(),
+  mime_type: z.string(),
+  extension: z.string(),
+  size: z.number().int(),
+  name: z.string(),
+  summary: z.nullable(z.string()).optional(),
+  created_at: z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  last_processed_at: z.nullable(
+    z.string().datetime({ offset: true }).transform(v => new Date(v)),
+  ).optional(),
+  number_of_pages: z.nullable(z.number().int()).optional(),
+  processing_status: z.string(),
+  uploaded_by_id: z.string(),
+  uploaded_by_type: z.string(),
+  tokens_processing_main_content: z.nullable(z.number().int()).optional(),
+  tokens_processing_summary: z.nullable(z.number().int()).optional(),
+  tokens_processing_total: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    "library_id": "libraryId",
+    "mime_type": "mimeType",
+    "created_at": "createdAt",
+    "last_processed_at": "lastProcessedAt",
+    "number_of_pages": "numberOfPages",
+    "processing_status": "processingStatus",
+    "uploaded_by_id": "uploadedById",
+    "uploaded_by_type": "uploadedByType",
+    "tokens_processing_main_content": "tokensProcessingMainContent",
+    "tokens_processing_summary": "tokensProcessingSummary",
+    "tokens_processing_total": "tokensProcessingTotal",
+  });
+});
+
+/** @internal */
+export type DocumentOut$Outbound = {
+  id: string;
+  library_id: string;
+  hash: string;
+  mime_type: string;
+  extension: string;
+  size: number;
+  name: string;
+  summary?: string | null | undefined;
+  created_at: string;
+  last_processed_at?: string | null | undefined;
+  number_of_pages?: number | null | undefined;
+  processing_status: string;
+  uploaded_by_id: string;
+  uploaded_by_type: string;
+  tokens_processing_main_content?: number | null | undefined;
+  tokens_processing_summary?: number | null | undefined;
+  tokens_processing_total: number;
+};
+
+/** @internal */
+export const DocumentOut$outboundSchema: z.ZodType<
+  DocumentOut$Outbound,
+  z.ZodTypeDef,
+  DocumentOut
+> = z.object({
+  id: z.string(),
+  libraryId: z.string(),
+  hash: z.string(),
+  mimeType: z.string(),
+  extension: z.string(),
+  size: z.number().int(),
+  name: z.string(),
+  summary: z.nullable(z.string()).optional(),
+  createdAt: z.date().transform(v => v.toISOString()),
+  lastProcessedAt: z.nullable(z.date().transform(v => v.toISOString()))
+    .optional(),
+  numberOfPages: z.nullable(z.number().int()).optional(),
+  processingStatus: z.string(),
+  uploadedById: z.string(),
+  uploadedByType: z.string(),
+  tokensProcessingMainContent: z.nullable(z.number().int()).optional(),
+  tokensProcessingSummary: z.nullable(z.number().int()).optional(),
+  tokensProcessingTotal: z.number().int(),
+}).transform((v) => {
+  return remap$(v, {
+    libraryId: "library_id",
+    mimeType: "mime_type",
+    createdAt: "created_at",
+    lastProcessedAt: "last_processed_at",
+    numberOfPages: "number_of_pages",
+    processingStatus: "processing_status",
+    uploadedById: "uploaded_by_id",
+    uploadedByType: "uploaded_by_type",
+    tokensProcessingMainContent: "tokens_processing_main_content",
+    tokensProcessingSummary: "tokens_processing_summary",
+    tokensProcessingTotal: "tokens_processing_total",
+  });
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DocumentOut$ {
+  /** @deprecated use `DocumentOut$inboundSchema` instead. */
+  export const inboundSchema = DocumentOut$inboundSchema;
+  /** @deprecated use `DocumentOut$outboundSchema` instead. */
+  export const outboundSchema = DocumentOut$outboundSchema;
+  /** @deprecated use `DocumentOut$Outbound` instead. */
+  export type Outbound = DocumentOut$Outbound;
+}
+
+export function documentOutToJSON(documentOut: DocumentOut): string {
+  return JSON.stringify(DocumentOut$outboundSchema.parse(documentOut));
+}
+
+export function documentOutFromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentOut, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DocumentOut$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentOut' from JSON`,
+  );
+}

package/src/models/components/documenttextcontent.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DocumentTextContent = {
+  text: string;
+};
+
+/** @internal */
+export const DocumentTextContent$inboundSchema: z.ZodType<
+  DocumentTextContent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+});
+
+/** @internal */
+export type DocumentTextContent$Outbound = {
+  text: string;
+};
+
+/** @internal */
+export const DocumentTextContent$outboundSchema: z.ZodType<
+  DocumentTextContent$Outbound,
+  z.ZodTypeDef,
+  DocumentTextContent
+> = z.object({
+  text: z.string(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DocumentTextContent$ {
+  /** @deprecated use `DocumentTextContent$inboundSchema` instead. */
+  export const inboundSchema = DocumentTextContent$inboundSchema;
+  /** @deprecated use `DocumentTextContent$outboundSchema` instead. */
+  export const outboundSchema = DocumentTextContent$outboundSchema;
+  /** @deprecated use `DocumentTextContent$Outbound` instead. */
+  export type Outbound = DocumentTextContent$Outbound;
+}
+
+export function documentTextContentToJSON(
+  documentTextContent: DocumentTextContent,
+): string {
+  return JSON.stringify(
+    DocumentTextContent$outboundSchema.parse(documentTextContent),
+  );
+}
+
+export function documentTextContentFromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentTextContent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DocumentTextContent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentTextContent' from JSON`,
+  );
+}

package/src/models/components/documentupdatein.ts

@@ -0,0 +1,66 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import { safeParse } from "../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type DocumentUpdateIn = {
+  name?: string | null | undefined;
+};
+
+/** @internal */
+export const DocumentUpdateIn$inboundSchema: z.ZodType<
+  DocumentUpdateIn,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+});
+
+/** @internal */
+export type DocumentUpdateIn$Outbound = {
+  name?: string | null | undefined;
+};
+
+/** @internal */
+export const DocumentUpdateIn$outboundSchema: z.ZodType<
+  DocumentUpdateIn$Outbound,
+  z.ZodTypeDef,
+  DocumentUpdateIn
+> = z.object({
+  name: z.nullable(z.string()).optional(),
+});
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace DocumentUpdateIn$ {
+  /** @deprecated use `DocumentUpdateIn$inboundSchema` instead. */
+  export const inboundSchema = DocumentUpdateIn$inboundSchema;
+  /** @deprecated use `DocumentUpdateIn$outboundSchema` instead. */
+  export const outboundSchema = DocumentUpdateIn$outboundSchema;
+  /** @deprecated use `DocumentUpdateIn$Outbound` instead. */
+  export type Outbound = DocumentUpdateIn$Outbound;
+}
+
+export function documentUpdateInToJSON(
+  documentUpdateIn: DocumentUpdateIn,
+): string {
+  return JSON.stringify(
+    DocumentUpdateIn$outboundSchema.parse(documentUpdateIn),
+  );
+}
+
+export function documentUpdateInFromJSON(
+  jsonString: string,
+): SafeParseResult<DocumentUpdateIn, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => DocumentUpdateIn$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'DocumentUpdateIn' from JSON`,
+  );
+}

package/src/models/components/entitytype.ts

@@ -0,0 +1,55 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod";
+import {
+  catchUnrecognizedEnum,
+  OpenEnum,
+  Unrecognized,
+} from "../../types/enums.js";
+
+/**
+ * The type of entity, used to share a library.
+ */
+export const EntityType = {
+  User: "User",
+  Workspace: "Workspace",
+  Org: "Org",
+} as const;
+/**
+ * The type of entity, used to share a library.
+ */
+export type EntityType = OpenEnum<typeof EntityType>;
+
+/** @internal */
+export const EntityType$inboundSchema: z.ZodType<
+  EntityType,
+  z.ZodTypeDef,
+  unknown
+> = z
+  .union([
+    z.nativeEnum(EntityType),
+    z.string().transform(catchUnrecognizedEnum),
+  ]);
+
+/** @internal */
+export const EntityType$outboundSchema: z.ZodType<
+  EntityType,
+  z.ZodTypeDef,
+  EntityType
+> = z.union([
+  z.nativeEnum(EntityType),
+  z.string().and(z.custom<Unrecognized<string>>()),
+]);
+
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export namespace EntityType$ {
+  /** @deprecated use `EntityType$inboundSchema` instead. */
+  export const inboundSchema = EntityType$inboundSchema;
+  /** @deprecated use `EntityType$outboundSchema` instead. */
+  export const outboundSchema = EntityType$outboundSchema;
+}