@openrouter/sdk 0.1.27 → 0.2.9

package/esm/models/responseoutputtext.js

@@ -4,22 +4,15 @@
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
 import { OpenAIResponsesAnnotation$inboundSchema, OpenAIResponsesAnnotation$outboundSchema, } from "./openairesponsesannotation.js";
-export const ResponseOutputTextType = {
-    OutputText: "output_text",
-};
-/** @internal */
-export const ResponseOutputTextType$inboundSchema = z.enum(ResponseOutputTextType);
-/** @internal */
-export const ResponseOutputTextType$outboundSchema = ResponseOutputTextType$inboundSchema;
 /** @internal */
 export const ResponseOutputText$inboundSchema = z.object({
-    type: ResponseOutputTextType$inboundSchema,
+    type: z.literal("output_text"),
     text: z.string(),
     annotations: z.array(OpenAIResponsesAnnotation$inboundSchema).optional(),
 });
 /** @internal */
 export const ResponseOutputText$outboundSchema = z.object({
-    type: ResponseOutputTextType$outboundSchema,
+    type: z.literal("output_text"),
     text: z.string(),
     annotations: z.array(OpenAIResponsesAnnotation$outboundSchema).optional(),
 });

package/esm/models/responsesformatjsonobject.d.ts

@@ -1,26 +1,17 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ResponsesFormatJSONObjectType: {
-    readonly JsonObject: "json_object";
-};
-export type ResponsesFormatJSONObjectType = ClosedEnum<typeof ResponsesFormatJSONObjectType>;
 /**
  * JSON object response format
  */
 export type ResponsesFormatJSONObject = {
-    type: ResponsesFormatJSONObjectType;
+    type: "json_object";
 };
 /** @internal */
-export declare const ResponsesFormatJSONObjectType$inboundSchema: z.ZodEnum<typeof ResponsesFormatJSONObjectType>;
-/** @internal */
-export declare const ResponsesFormatJSONObjectType$outboundSchema: z.ZodEnum<typeof ResponsesFormatJSONObjectType>;
-/** @internal */
 export declare const ResponsesFormatJSONObject$inboundSchema: z.ZodType<ResponsesFormatJSONObject, unknown>;
 /** @internal */
 export type ResponsesFormatJSONObject$Outbound = {
-    type: string;
+    type: "json_object";
 };
 /** @internal */
 export declare const ResponsesFormatJSONObject$outboundSchema: z.ZodType<ResponsesFormatJSONObject$Outbound, ResponsesFormatJSONObject>;

package/esm/models/responsesformatjsonobject.js

@@ -3,20 +3,13 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-export const ResponsesFormatJSONObjectType = {
-    JsonObject: "json_object",
-};
-/** @internal */
-export const ResponsesFormatJSONObjectType$inboundSchema = z.enum(ResponsesFormatJSONObjectType);
-/** @internal */
-export const ResponsesFormatJSONObjectType$outboundSchema = ResponsesFormatJSONObjectType$inboundSchema;
 /** @internal */
 export const ResponsesFormatJSONObject$inboundSchema = z.object({
-    type: ResponsesFormatJSONObjectType$inboundSchema,
+    type: z.literal("json_object"),
 });
 /** @internal */
 export const ResponsesFormatJSONObject$outboundSchema = z.object({
-    type: ResponsesFormatJSONObjectType$outboundSchema,
+    type: z.literal("json_object"),
 });
 export function responsesFormatJSONObjectToJSON(responsesFormatJSONObject) {
     return JSON.stringify(ResponsesFormatJSONObject$outboundSchema.parse(responsesFormatJSONObject));

package/esm/models/responsesformattext.d.ts

@@ -1,26 +1,17 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ResponsesFormatTextType: {
-    readonly Text: "text";
-};
-export type ResponsesFormatTextType = ClosedEnum<typeof ResponsesFormatTextType>;
 /**
  * Plain text response format
  */
 export type ResponsesFormatText = {
-    type: ResponsesFormatTextType;
+    type: "text";
 };
 /** @internal */
-export declare const ResponsesFormatTextType$inboundSchema: z.ZodEnum<typeof ResponsesFormatTextType>;
-/** @internal */
-export declare const ResponsesFormatTextType$outboundSchema: z.ZodEnum<typeof ResponsesFormatTextType>;
-/** @internal */
 export declare const ResponsesFormatText$inboundSchema: z.ZodType<ResponsesFormatText, unknown>;
 /** @internal */
 export type ResponsesFormatText$Outbound = {
-    type: string;
+    type: "text";
 };
 /** @internal */
 export declare const ResponsesFormatText$outboundSchema: z.ZodType<ResponsesFormatText$Outbound, ResponsesFormatText>;

package/esm/models/responsesformattext.js

@@ -3,20 +3,13 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-export const ResponsesFormatTextType = {
-    Text: "text",
-};
-/** @internal */
-export const ResponsesFormatTextType$inboundSchema = z.enum(ResponsesFormatTextType);
-/** @internal */
-export const ResponsesFormatTextType$outboundSchema = ResponsesFormatTextType$inboundSchema;
 /** @internal */
 export const ResponsesFormatText$inboundSchema = z.object({
-    type: ResponsesFormatTextType$inboundSchema,
+    type: z.literal("text"),
 });
 /** @internal */
 export const ResponsesFormatText$outboundSchema = z.object({
-    type: ResponsesFormatTextType$outboundSchema,
+    type: z.literal("text"),
 });
 export function responsesFormatTextToJSON(responsesFormatText) {
     return JSON.stringify(ResponsesFormatText$outboundSchema.parse(responsesFormatText));

package/esm/models/responsesformattextjsonschemaconfig.d.ts

@@ -1,16 +1,11 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const ResponsesFormatTextJSONSchemaConfigType: {
-    readonly JsonSchema: "json_schema";
-};
-export type ResponsesFormatTextJSONSchemaConfigType = ClosedEnum<typeof ResponsesFormatTextJSONSchemaConfigType>;
 /**
  * JSON schema constrained response format
  */
 export type ResponsesFormatTextJSONSchemaConfig = {
-    type: ResponsesFormatTextJSONSchemaConfigType;
+    type: "json_schema";
     name: string;
     description?: string | undefined;
     strict?: boolean | null | undefined;
@@ -19,14 +14,10 @@ export type ResponsesFormatTextJSONSchemaConfig = {
     };
 };
 /** @internal */
-export declare const ResponsesFormatTextJSONSchemaConfigType$inboundSchema: z.ZodEnum<typeof ResponsesFormatTextJSONSchemaConfigType>;
-/** @internal */
-export declare const ResponsesFormatTextJSONSchemaConfigType$outboundSchema: z.ZodEnum<typeof ResponsesFormatTextJSONSchemaConfigType>;
-/** @internal */
 export declare const ResponsesFormatTextJSONSchemaConfig$inboundSchema: z.ZodType<ResponsesFormatTextJSONSchemaConfig, unknown>;
 /** @internal */
 export type ResponsesFormatTextJSONSchemaConfig$Outbound = {
-    type: string;
+    type: "json_schema";
     name: string;
     description?: string | undefined;
     strict?: boolean | null | undefined;

package/esm/models/responsesformattextjsonschemaconfig.js

@@ -3,16 +3,9 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-export const ResponsesFormatTextJSONSchemaConfigType = {
-    JsonSchema: "json_schema",
-};
-/** @internal */
-export const ResponsesFormatTextJSONSchemaConfigType$inboundSchema = z.enum(ResponsesFormatTextJSONSchemaConfigType);
-/** @internal */
-export const ResponsesFormatTextJSONSchemaConfigType$outboundSchema = ResponsesFormatTextJSONSchemaConfigType$inboundSchema;
 /** @internal */
 export const ResponsesFormatTextJSONSchemaConfig$inboundSchema = z.object({
-    type: ResponsesFormatTextJSONSchemaConfigType$inboundSchema,
+    type: z.literal("json_schema"),
     name: z.string(),
     description: z.string().optional(),
     strict: z.nullable(z.boolean()).optional(),
@@ -20,7 +13,7 @@ export const ResponsesFormatTextJSONSchemaConfig$inboundSchema = z.object({
 });
 /** @internal */
 export const ResponsesFormatTextJSONSchemaConfig$outboundSchema = z.object({
-    type: ResponsesFormatTextJSONSchemaConfigType$outboundSchema,
+    type: z.literal("json_schema"),
     name: z.string(),
     description: z.string().optional(),
     strict: z.nullable(z.boolean()).optional(),

package/esm/models/responsesoutputitem.d.ts

@@ -10,7 +10,19 @@ import { ResponsesWebSearchCallOutput } from "./responseswebsearchcalloutput.js"
 /**
  * An output item from the response
  */
-export type ResponsesOutputItem = ResponsesOutputMessage | ResponsesOutputItemFunctionCall | ResponsesOutputItemFileSearchCall | ResponsesOutputItemReasoning | ResponsesWebSearchCallOutput | ResponsesImageGenerationCall;
+export type ResponsesOutputItem = (ResponsesOutputMessage & {
+    type: "message";
+}) | (ResponsesOutputItemReasoning & {
+    type: "reasoning";
+}) | (ResponsesOutputItemFunctionCall & {
+    type: "function_call";
+}) | (ResponsesWebSearchCallOutput & {
+    type: "web_search_call";
+}) | (ResponsesOutputItemFileSearchCall & {
+    type: "file_search_call";
+}) | (ResponsesImageGenerationCall & {
+    type: "image_generation_call";
+});
 /** @internal */
 export declare const ResponsesOutputItem$inboundSchema: z.ZodType<ResponsesOutputItem, unknown>;
 export declare function responsesOutputItemFromJSON(jsonString: string): SafeParseResult<ResponsesOutputItem, SDKValidationError>;

package/esm/models/responsesoutputitem.js

@@ -11,12 +11,12 @@ import { ResponsesOutputMessage$inboundSchema, } from "./responsesoutputmessage.
 import { ResponsesWebSearchCallOutput$inboundSchema, } from "./responseswebsearchcalloutput.js";
 /** @internal */
 export const ResponsesOutputItem$inboundSchema = z.union([
-    ResponsesOutputMessage$inboundSchema,
-    ResponsesOutputItemFunctionCall$inboundSchema,
-    ResponsesOutputItemFileSearchCall$inboundSchema,
-    ResponsesOutputItemReasoning$inboundSchema,
-    ResponsesWebSearchCallOutput$inboundSchema,
-    ResponsesImageGenerationCall$inboundSchema,
+    ResponsesOutputMessage$inboundSchema.and(z.object({ type: z.literal("message") })),
+    ResponsesOutputItemReasoning$inboundSchema.and(z.object({ type: z.literal("reasoning") })),
+    ResponsesOutputItemFunctionCall$inboundSchema.and(z.object({ type: z.literal("function_call") })),
+    ResponsesWebSearchCallOutput$inboundSchema.and(z.object({ type: z.literal("web_search_call") })),
+    ResponsesOutputItemFileSearchCall$inboundSchema.and(z.object({ type: z.literal("file_search_call") })),
+    ResponsesImageGenerationCall$inboundSchema.and(z.object({ type: z.literal("image_generation_call") })),
 ]);
 export function responsesOutputItemFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ResponsesOutputItem$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ResponsesOutputItem' from JSON`);

package/esm/models/urlcitation.d.ts

@@ -1,27 +1,18 @@
 import * as z from "zod/v4";
-import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export declare const URLCitationType: {
-    readonly UrlCitation: "url_citation";
-};
-export type URLCitationType = ClosedEnum<typeof URLCitationType>;
 export type URLCitation = {
-    type: URLCitationType;
+    type: "url_citation";
     url: string;
     title: string;
     startIndex: number;
     endIndex: number;
 };
 /** @internal */
-export declare const URLCitationType$inboundSchema: z.ZodEnum<typeof URLCitationType>;
-/** @internal */
-export declare const URLCitationType$outboundSchema: z.ZodEnum<typeof URLCitationType>;
-/** @internal */
 export declare const URLCitation$inboundSchema: z.ZodType<URLCitation, unknown>;
 /** @internal */
 export type URLCitation$Outbound = {
-    type: string;
+    type: "url_citation";
     url: string;
     title: string;
     start_index: number;

package/esm/models/urlcitation.js

@@ -4,17 +4,10 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-export const URLCitationType = {
-    UrlCitation: "url_citation",
-};
-/** @internal */
-export const URLCitationType$inboundSchema = z.enum(URLCitationType);
-/** @internal */
-export const URLCitationType$outboundSchema = URLCitationType$inboundSchema;
 /** @internal */
 export const URLCitation$inboundSchema = z
     .object({
-    type: URLCitationType$inboundSchema,
+    type: z.literal("url_citation"),
     url: z.string(),
     title: z.string(),
     start_index: z.number(),
@@ -27,7 +20,7 @@ export const URLCitation$inboundSchema = z
 });
 /** @internal */
 export const URLCitation$outboundSchema = z.object({
-    type: URLCitationType$outboundSchema,
+    type: z.literal("url_citation"),
     url: z.string(),
     title: z.string(),
     startIndex: z.number(),

package/esm/sdk/oauth.d.ts

@@ -1,7 +1,7 @@
 import { ClientSDK, RequestOptions } from "../lib/sdks.js";
 import * as operations from "../models/operations/index.js";
-import { CreateAuthorizationUrlRequest } from "../funcs/oAuthCreateAuthorizationUrl.js";
-import { CreateSHA256CodeChallengeResponse } from "../funcs/oAuthCreateSHA256CodeChallenge.js";
+import type { CreateAuthorizationUrlRequest } from "../funcs/oAuthCreateAuthorizationUrl.js";
+import type { CreateSHA256CodeChallengeResponse } from "../funcs/oAuthCreateSHA256CodeChallenge.js";
 export declare class OAuth extends ClientSDK {
     /**
      * Generate a OAuth2 authorization URL

package/esm/sdk/oauth.js

@@ -5,9 +5,8 @@ import { oAuthCreateAuthCode } from "../funcs/oAuthCreateAuthCode.js";
 import { oAuthExchangeAuthCodeForAPIKey } from "../funcs/oAuthExchangeAuthCodeForAPIKey.js";
 import { ClientSDK } from "../lib/sdks.js";
 import { unwrapAsync } from "../types/fp.js";
-// #region imports
-import { oAuthCreateAuthorizationUrl, } from "../funcs/oAuthCreateAuthorizationUrl.js";
-import { oAuthCreateSHA256CodeChallenge, } from "../funcs/oAuthCreateSHA256CodeChallenge.js";
+import { oAuthCreateAuthorizationUrl } from "../funcs/oAuthCreateAuthorizationUrl.js";
+import { oAuthCreateSHA256CodeChallenge } from "../funcs/oAuthCreateSHA256CodeChallenge.js";
 // #endregion imports
 export class OAuth extends ClientSDK {
     // #region sdk-class-body

package/esm/sdk/sdk.d.ts

@@ -12,12 +12,13 @@ import { Models } from "./models.js";
 import { OAuth } from "./oauth.js";
 import { ParametersT } from "./parameters.js";
 import { Providers } from "./providers.js";
-import { ResponseWrapper } from "../lib/response-wrapper.js";
-import { RequestOptions } from "../lib/sdks.js";
-import { EnhancedTool, MaxToolRounds, ToolType } from "../lib/tool-types.js";
-import * as models from "../models/index.js";
+import type { ResponseWrapper } from "../lib/response-wrapper.js";
+import type { RequestOptions } from "../lib/sdks.js";
+import { type MaxToolRounds, Tool, ToolType } from "../lib/tool-types.js";
+import type { OpenResponsesInput } from "../models/openresponsesinput.js";
+import type { OpenResponsesRequest } from "../models/openresponsesrequest.js";
 export { ToolType };
-export type { EnhancedTool, MaxToolRounds };
+export type { MaxToolRounds };
 export declare class OpenRouter extends ClientSDK {
     private _beta?;
     get beta(): Beta;
@@ -45,9 +46,9 @@ export declare class OpenRouter extends ClientSDK {
     get chat(): Chat;
     private _completions?;
     get completions(): Completions;
-    callModel(request: Omit<models.OpenResponsesRequest, "stream" | "tools" | "input"> & {
-        input?: import("../funcs/callModel.js").CallModelInput;
-        tools?: import("../funcs/callModel.js").CallModelTools;
+    callModel(request: Omit<OpenResponsesRequest, "stream" | "tools" | "input"> & {
+        input?: OpenResponsesInput;
+        tools?: Tool[];
         maxToolRounds?: MaxToolRounds;
     }, options?: RequestOptions): ResponseWrapper;
 }

package/esm/types/unrecognized.d.ts

@@ -4,7 +4,13 @@ export type Unrecognized<T> = T & {
 };
 declare function unrecognized<T>(value: T): Unrecognized<T>;
 export declare function startCountingUnrecognized(): {
-    end: () => number;
+    /**
+     * Ends counting and returns the delta.
+     * @param delta - If provided, only this amount is added to the parent counter
+     *   (used for nested unions where we only want to record the winning option's count).
+     *   If not provided, records all counts since start().
+     */
+    end: (delta?: number) => number;
 };
 export { unrecognized };
 //# sourceMappingURL=unrecognized.d.ts.map

package/esm/types/unrecognized.js

@@ -11,8 +11,16 @@ export function startCountingUnrecognized() {
     refCount++;
     const start = globalCount;
     return {
-        end: () => {
+        /**
+         * Ends counting and returns the delta.
+         * @param delta - If provided, only this amount is added to the parent counter
+         *   (used for nested unions where we only want to record the winning option's count).
+         *   If not provided, records all counts since start().
+         */
+        end: (delta) => {
             const count = globalCount - start;
+            // Reset globalCount back to start, then add only the specified delta
+            globalCount = start + (delta ?? count);
             if (--refCount === 0)
                 globalCount = 0;
             return count;

package/jsr.json

@@ -2,7 +2,7 @@
 
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.27",
+  "version": "0.2.9",
   "exports": {
     ".": "./src/index.ts",    
     "./models/errors": "./src/models/errors/index.ts",    

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openrouter/sdk",
-  "version": "0.1.27",
+  "version": "0.2.9",
   "author": "OpenRouter",
   "description": "The OpenRouter TypeScript SDK is a type-safe toolkit for building AI applications with access to 300+ language models through a unified API.",
   "keywords": [

package/tsconfig.json

@@ -1,7 +1,6 @@
 {
   "compilerOptions": {
     "incremental": true,
-    "tsBuildInfoFile": ".tsbuildinfo",
     "target": "ES2020",
     "lib": ["ES2022", "DOM", "DOM.Iterable"],
     "jsx": "react-jsx",

package/vitest.config.ts

@@ -1,30 +1,36 @@
-import { config } from "dotenv";
-import { defineConfig } from "vitest/config";
-import { fileURLToPath } from "url";
-import { dirname, join } from "path";
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { config } from 'dotenv';
+import { defineConfig } from 'vitest/config';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 // Load environment variables from .env file if it exists
 // This will not override existing environment variables
-config({ path: join(__dirname, ".env") });
+config({
+  path: join(__dirname, '.env'),
+});
 
 export default defineConfig({
   test: {
     globals: true,
-    environment: "node",
+    environment: 'node',
     // Don't override env vars - just let them pass through from the system
     // The env object here will be merged with process.env
     env: {
       OPENROUTER_API_KEY: process.env.OPENROUTER_API_KEY,
     },
-    include: ["tests/**/*.test.ts"],
+    include: [
+      'tests/**/*.test.ts',
+    ],
     hookTimeout: 30000,
     testTimeout: 30000,
     typecheck: {
       enabled: true,
-      include: ["tests/**/*.test.ts"],
+      include: [
+        'tests/**/*.test.ts',
+      ],
     },
   },
 });

package/esm/models/chatmessagecontentitemfile.d.ts

@@ -1,36 +0,0 @@
-import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../types/fp.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type FileT = {
-    fileData: string;
-    fileId?: string | undefined;
-    filename?: string | undefined;
-};
-export type ChatMessageContentItemFile = {
-    type: "file";
-    file: FileT;
-};
-/** @internal */
-export declare const FileT$inboundSchema: z.ZodType<FileT, unknown>;
-/** @internal */
-export type FileT$Outbound = {
-    file_data: string;
-    file_id?: string | undefined;
-    filename?: string | undefined;
-};
-/** @internal */
-export declare const FileT$outboundSchema: z.ZodType<FileT$Outbound, FileT>;
-export declare function fileToJSON(fileT: FileT): string;
-export declare function fileFromJSON(jsonString: string): SafeParseResult<FileT, SDKValidationError>;
-/** @internal */
-export declare const ChatMessageContentItemFile$inboundSchema: z.ZodType<ChatMessageContentItemFile, unknown>;
-/** @internal */
-export type ChatMessageContentItemFile$Outbound = {
-    type: "file";
-    file: FileT$Outbound;
-};
-/** @internal */
-export declare const ChatMessageContentItemFile$outboundSchema: z.ZodType<ChatMessageContentItemFile$Outbound, ChatMessageContentItemFile>;
-export declare function chatMessageContentItemFileToJSON(chatMessageContentItemFile: ChatMessageContentItemFile): string;
-export declare function chatMessageContentItemFileFromJSON(jsonString: string): SafeParseResult<ChatMessageContentItemFile, SDKValidationError>;
-//# sourceMappingURL=chatmessagecontentitemfile.d.ts.map

package/esm/models/chatmessagecontentitemfile.js

@@ -1,51 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-import * as z from "zod/v4";
-import { remap as remap$ } from "../lib/primitives.js";
-import { safeParse } from "../lib/schemas.js";
-/** @internal */
-export const FileT$inboundSchema = z.object({
-    file_data: z.string(),
-    file_id: z.string().optional(),
-    filename: z.string().optional(),
-}).transform((v) => {
-    return remap$(v, {
-        "file_data": "fileData",
-        "file_id": "fileId",
-    });
-});
-/** @internal */
-export const FileT$outboundSchema = z.object({
-    fileData: z.string(),
-    fileId: z.string().optional(),
-    filename: z.string().optional(),
-}).transform((v) => {
-    return remap$(v, {
-        fileData: "file_data",
-        fileId: "file_id",
-    });
-});
-export function fileToJSON(fileT) {
-    return JSON.stringify(FileT$outboundSchema.parse(fileT));
-}
-export function fileFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => FileT$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'FileT' from JSON`);
-}
-/** @internal */
-export const ChatMessageContentItemFile$inboundSchema = z.object({
-    type: z.literal("file"),
-    file: z.lazy(() => FileT$inboundSchema),
-});
-/** @internal */
-export const ChatMessageContentItemFile$outboundSchema = z.object({
-    type: z.literal("file"),
-    file: z.lazy(() => FileT$outboundSchema),
-});
-export function chatMessageContentItemFileToJSON(chatMessageContentItemFile) {
-    return JSON.stringify(ChatMessageContentItemFile$outboundSchema.parse(chatMessageContentItemFile));
-}
-export function chatMessageContentItemFileFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageContentItemFile$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageContentItemFile' from JSON`);
-}
-//# sourceMappingURL=chatmessagecontentitemfile.js.map

package/esm/models/videourl.d.ts

@@ -1,17 +0,0 @@
-import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../types/fp.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type VideoURL = {
-    url: string;
-};
-/** @internal */
-export declare const VideoURL$inboundSchema: z.ZodType<VideoURL, unknown>;
-/** @internal */
-export type VideoURL$Outbound = {
-    url: string;
-};
-/** @internal */
-export declare const VideoURL$outboundSchema: z.ZodType<VideoURL$Outbound, VideoURL>;
-export declare function videoURLToJSON(videoURL: VideoURL): string;
-export declare function videoURLFromJSON(jsonString: string): SafeParseResult<VideoURL, SDKValidationError>;
-//# sourceMappingURL=videourl.d.ts.map

package/esm/models/videourl.js

@@ -1,21 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-import * as z from "zod/v4";
-import { safeParse } from "../lib/schemas.js";
-/** @internal */
-export const VideoURL$inboundSchema = z.object({
-    url: z.string(),
-});
-/** @internal */
-export const VideoURL$outboundSchema = z
-    .object({
-    url: z.string(),
-});
-export function videoURLToJSON(videoURL) {
-    return JSON.stringify(VideoURL$outboundSchema.parse(videoURL));
-}
-export function videoURLFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => VideoURL$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'VideoURL' from JSON`);
-}
-//# sourceMappingURL=videourl.js.map