@openrouter/sdk 0.1.2 → 0.1.4

package/esm/models/chatmessagetokenlogprob.js

@@ -11,26 +11,6 @@ export const TopLogprob$inboundSchema = z
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
 });
-/** @internal */
-export const TopLogprob$outboundSchema = z.object({
-    token: z.string(),
-    logprob: z.number(),
-    bytes: z.nullable(z.array(z.number())),
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var TopLogprob$;
-(function (TopLogprob$) {
-    /** @deprecated use `TopLogprob$inboundSchema` instead. */
-    TopLogprob$.inboundSchema = TopLogprob$inboundSchema;
-    /** @deprecated use `TopLogprob$outboundSchema` instead. */
-    TopLogprob$.outboundSchema = TopLogprob$outboundSchema;
-})(TopLogprob$ || (TopLogprob$ = {}));
-export function topLogprobToJSON(topLogprob) {
-    return JSON.stringify(TopLogprob$outboundSchema.parse(topLogprob));
-}
 export function topLogprobFromJSON(jsonString) {
     return safeParse(jsonString, (x) => TopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TopLogprob' from JSON`);
 }
@@ -45,31 +25,6 @@ export const ChatMessageTokenLogprob$inboundSchema = z.object({
         "top_logprobs": "topLogprobs",
     });
 });
-/** @internal */
-export const ChatMessageTokenLogprob$outboundSchema = z.object({
-    token: z.string(),
-    logprob: z.number(),
-    bytes: z.nullable(z.array(z.number())),
-    topLogprobs: z.array(z.lazy(() => TopLogprob$outboundSchema)),
-}).transform((v) => {
-    return remap$(v, {
-        topLogprobs: "top_logprobs",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatMessageTokenLogprob$;
-(function (ChatMessageTokenLogprob$) {
-    /** @deprecated use `ChatMessageTokenLogprob$inboundSchema` instead. */
-    ChatMessageTokenLogprob$.inboundSchema = ChatMessageTokenLogprob$inboundSchema;
-    /** @deprecated use `ChatMessageTokenLogprob$outboundSchema` instead. */
-    ChatMessageTokenLogprob$.outboundSchema = ChatMessageTokenLogprob$outboundSchema;
-})(ChatMessageTokenLogprob$ || (ChatMessageTokenLogprob$ = {}));
-export function chatMessageTokenLogprobToJSON(chatMessageTokenLogprob) {
-    return JSON.stringify(ChatMessageTokenLogprob$outboundSchema.parse(chatMessageTokenLogprob));
-}
 export function chatMessageTokenLogprobFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatMessageTokenLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageTokenLogprob' from JSON`);
 }

package/esm/models/chatmessagetokenlogprobs.d.ts

@@ -1,6 +1,6 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatMessageTokenLogprob, ChatMessageTokenLogprob$Outbound } from "./chatmessagetokenlogprob.js";
+import { ChatMessageTokenLogprob } from "./chatmessagetokenlogprob.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatMessageTokenLogprobs = {
     content: Array<ChatMessageTokenLogprob> | null;
@@ -8,25 +8,5 @@ export type ChatMessageTokenLogprobs = {
 };
 /** @internal */
 export declare const ChatMessageTokenLogprobs$inboundSchema: z.ZodType<ChatMessageTokenLogprobs, unknown>;
-/** @internal */
-export type ChatMessageTokenLogprobs$Outbound = {
-    content: Array<ChatMessageTokenLogprob$Outbound> | null;
-    refusal: Array<ChatMessageTokenLogprob$Outbound> | null;
-};
-/** @internal */
-export declare const ChatMessageTokenLogprobs$outboundSchema: z.ZodType<ChatMessageTokenLogprobs$Outbound, ChatMessageTokenLogprobs>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatMessageTokenLogprobs$ {
-    /** @deprecated use `ChatMessageTokenLogprobs$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatMessageTokenLogprobs, unknown, z.core.$ZodTypeInternals<ChatMessageTokenLogprobs, unknown>>;
-    /** @deprecated use `ChatMessageTokenLogprobs$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatMessageTokenLogprobs$Outbound, ChatMessageTokenLogprobs, z.core.$ZodTypeInternals<ChatMessageTokenLogprobs$Outbound, ChatMessageTokenLogprobs>>;
-    /** @deprecated use `ChatMessageTokenLogprobs$Outbound` instead. */
-    type Outbound = ChatMessageTokenLogprobs$Outbound;
-}
-export declare function chatMessageTokenLogprobsToJSON(chatMessageTokenLogprobs: ChatMessageTokenLogprobs): string;
 export declare function chatMessageTokenLogprobsFromJSON(jsonString: string): SafeParseResult<ChatMessageTokenLogprobs, SDKValidationError>;
 //# sourceMappingURL=chatmessagetokenlogprobs.d.ts.map

package/esm/models/chatmessagetokenlogprobs.js

@@ -3,31 +3,12 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import { ChatMessageTokenLogprob$inboundSchema, ChatMessageTokenLogprob$outboundSchema, } from "./chatmessagetokenlogprob.js";
+import { ChatMessageTokenLogprob$inboundSchema, } from "./chatmessagetokenlogprob.js";
 /** @internal */
 export const ChatMessageTokenLogprobs$inboundSchema = z.object({
     content: z.nullable(z.array(ChatMessageTokenLogprob$inboundSchema)),
     refusal: z.nullable(z.array(ChatMessageTokenLogprob$inboundSchema)),
 });
-/** @internal */
-export const ChatMessageTokenLogprobs$outboundSchema = z.object({
-    content: z.nullable(z.array(ChatMessageTokenLogprob$outboundSchema)),
-    refusal: z.nullable(z.array(ChatMessageTokenLogprob$outboundSchema)),
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatMessageTokenLogprobs$;
-(function (ChatMessageTokenLogprobs$) {
-    /** @deprecated use `ChatMessageTokenLogprobs$inboundSchema` instead. */
-    ChatMessageTokenLogprobs$.inboundSchema = ChatMessageTokenLogprobs$inboundSchema;
-    /** @deprecated use `ChatMessageTokenLogprobs$outboundSchema` instead. */
-    ChatMessageTokenLogprobs$.outboundSchema = ChatMessageTokenLogprobs$outboundSchema;
-})(ChatMessageTokenLogprobs$ || (ChatMessageTokenLogprobs$ = {}));
-export function chatMessageTokenLogprobsToJSON(chatMessageTokenLogprobs) {
-    return JSON.stringify(ChatMessageTokenLogprobs$outboundSchema.parse(chatMessageTokenLogprobs));
-}
 export function chatMessageTokenLogprobsFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatMessageTokenLogprobs$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageTokenLogprobs' from JSON`);
 }

package/esm/models/chatmessagetoolcall.d.ts

@@ -19,18 +19,6 @@ export type ChatMessageToolCallFunction$Outbound = {
 };
 /** @internal */
 export declare const ChatMessageToolCallFunction$outboundSchema: z.ZodType<ChatMessageToolCallFunction$Outbound, ChatMessageToolCallFunction>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatMessageToolCallFunction$ {
-    /** @deprecated use `ChatMessageToolCallFunction$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatMessageToolCallFunction, unknown, z.core.$ZodTypeInternals<ChatMessageToolCallFunction, unknown>>;
-    /** @deprecated use `ChatMessageToolCallFunction$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatMessageToolCallFunction$Outbound, ChatMessageToolCallFunction, z.core.$ZodTypeInternals<ChatMessageToolCallFunction$Outbound, ChatMessageToolCallFunction>>;
-    /** @deprecated use `ChatMessageToolCallFunction$Outbound` instead. */
-    type Outbound = ChatMessageToolCallFunction$Outbound;
-}
 export declare function chatMessageToolCallFunctionToJSON(chatMessageToolCallFunction: ChatMessageToolCallFunction): string;
 export declare function chatMessageToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatMessageToolCallFunction, SDKValidationError>;
 /** @internal */
@@ -43,18 +31,6 @@ export type ChatMessageToolCall$Outbound = {
 };
 /** @internal */
 export declare const ChatMessageToolCall$outboundSchema: z.ZodType<ChatMessageToolCall$Outbound, ChatMessageToolCall>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatMessageToolCall$ {
-    /** @deprecated use `ChatMessageToolCall$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatMessageToolCall, unknown, z.core.$ZodTypeInternals<ChatMessageToolCall, unknown>>;
-    /** @deprecated use `ChatMessageToolCall$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatMessageToolCall$Outbound, ChatMessageToolCall, z.core.$ZodTypeInternals<ChatMessageToolCall$Outbound, ChatMessageToolCall>>;
-    /** @deprecated use `ChatMessageToolCall$Outbound` instead. */
-    type Outbound = ChatMessageToolCall$Outbound;
-}
 export declare function chatMessageToolCallToJSON(chatMessageToolCall: ChatMessageToolCall): string;
 export declare function chatMessageToolCallFromJSON(jsonString: string): SafeParseResult<ChatMessageToolCall, SDKValidationError>;
 //# sourceMappingURL=chatmessagetoolcall.d.ts.map

package/esm/models/chatmessagetoolcall.js

@@ -13,17 +13,6 @@ export const ChatMessageToolCallFunction$outboundSchema = z.object({
     name: z.string(),
     arguments: z.string(),
 });
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatMessageToolCallFunction$;
-(function (ChatMessageToolCallFunction$) {
-    /** @deprecated use `ChatMessageToolCallFunction$inboundSchema` instead. */
-    ChatMessageToolCallFunction$.inboundSchema = ChatMessageToolCallFunction$inboundSchema;
-    /** @deprecated use `ChatMessageToolCallFunction$outboundSchema` instead. */
-    ChatMessageToolCallFunction$.outboundSchema = ChatMessageToolCallFunction$outboundSchema;
-})(ChatMessageToolCallFunction$ || (ChatMessageToolCallFunction$ = {}));
 export function chatMessageToolCallFunctionToJSON(chatMessageToolCallFunction) {
     return JSON.stringify(ChatMessageToolCallFunction$outboundSchema.parse(chatMessageToolCallFunction));
 }
@@ -42,17 +31,6 @@ export const ChatMessageToolCall$outboundSchema = z.object({
     type: z.literal("function"),
     function: z.lazy(() => ChatMessageToolCallFunction$outboundSchema),
 });
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatMessageToolCall$;
-(function (ChatMessageToolCall$) {
-    /** @deprecated use `ChatMessageToolCall$inboundSchema` instead. */
-    ChatMessageToolCall$.inboundSchema = ChatMessageToolCall$inboundSchema;
-    /** @deprecated use `ChatMessageToolCall$outboundSchema` instead. */
-    ChatMessageToolCall$.outboundSchema = ChatMessageToolCall$outboundSchema;
-})(ChatMessageToolCall$ || (ChatMessageToolCall$ = {}));
 export function chatMessageToolCallToJSON(chatMessageToolCall) {
     return JSON.stringify(ChatMessageToolCall$outboundSchema.parse(chatMessageToolCall));
 }

package/esm/models/chatresponse.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatGenerationTokenUsage, ChatGenerationTokenUsage$Outbound } from "./chatgenerationtokenusage.js";
-import { ChatResponseChoice, ChatResponseChoice$Outbound } from "./chatresponsechoice.js";
+import { ChatGenerationTokenUsage } from "./chatgenerationtokenusage.js";
+import { ChatResponseChoice } from "./chatresponsechoice.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatResponse = {
     id: string;
@@ -14,30 +14,5 @@ export type ChatResponse = {
 };
 /** @internal */
 export declare const ChatResponse$inboundSchema: z.ZodType<ChatResponse, unknown>;
-/** @internal */
-export type ChatResponse$Outbound = {
-    id: string;
-    choices: Array<ChatResponseChoice$Outbound>;
-    created: number;
-    model: string;
-    object: "chat.completion";
-    system_fingerprint?: string | null | undefined;
-    usage?: ChatGenerationTokenUsage$Outbound | undefined;
-};
-/** @internal */
-export declare const ChatResponse$outboundSchema: z.ZodType<ChatResponse$Outbound, ChatResponse>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatResponse$ {
-    /** @deprecated use `ChatResponse$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatResponse, unknown, z.core.$ZodTypeInternals<ChatResponse, unknown>>;
-    /** @deprecated use `ChatResponse$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatResponse$Outbound, ChatResponse, z.core.$ZodTypeInternals<ChatResponse$Outbound, ChatResponse>>;
-    /** @deprecated use `ChatResponse$Outbound` instead. */
-    type Outbound = ChatResponse$Outbound;
-}
-export declare function chatResponseToJSON(chatResponse: ChatResponse): string;
 export declare function chatResponseFromJSON(jsonString: string): SafeParseResult<ChatResponse, SDKValidationError>;
 //# sourceMappingURL=chatresponse.d.ts.map

package/esm/models/chatresponse.js

@@ -4,8 +4,8 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ChatGenerationTokenUsage$inboundSchema, ChatGenerationTokenUsage$outboundSchema, } from "./chatgenerationtokenusage.js";
-import { ChatResponseChoice$inboundSchema, ChatResponseChoice$outboundSchema, } from "./chatresponsechoice.js";
+import { ChatGenerationTokenUsage$inboundSchema, } from "./chatgenerationtokenusage.js";
+import { ChatResponseChoice$inboundSchema, } from "./chatresponsechoice.js";
 /** @internal */
 export const ChatResponse$inboundSchema = z
     .object({
@@ -21,34 +21,6 @@ export const ChatResponse$inboundSchema = z
         "system_fingerprint": "systemFingerprint",
     });
 });
-/** @internal */
-export const ChatResponse$outboundSchema = z.object({
-    id: z.string(),
-    choices: z.array(ChatResponseChoice$outboundSchema),
-    created: z.number(),
-    model: z.string(),
-    object: z.literal("chat.completion"),
-    systemFingerprint: z.nullable(z.string()).optional(),
-    usage: ChatGenerationTokenUsage$outboundSchema.optional(),
-}).transform((v) => {
-    return remap$(v, {
-        systemFingerprint: "system_fingerprint",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatResponse$;
-(function (ChatResponse$) {
-    /** @deprecated use `ChatResponse$inboundSchema` instead. */
-    ChatResponse$.inboundSchema = ChatResponse$inboundSchema;
-    /** @deprecated use `ChatResponse$outboundSchema` instead. */
-    ChatResponse$.outboundSchema = ChatResponse$outboundSchema;
-})(ChatResponse$ || (ChatResponse$ = {}));
-export function chatResponseToJSON(chatResponse) {
-    return JSON.stringify(ChatResponse$outboundSchema.parse(chatResponse));
-}
 export function chatResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatResponse' from JSON`);
 }

package/esm/models/chatresponsechoice.d.ts

@@ -1,8 +1,8 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { AssistantMessage, AssistantMessage$Outbound } from "./assistantmessage.js";
+import { AssistantMessage } from "./assistantmessage.js";
 import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
-import { ChatMessageTokenLogprobs, ChatMessageTokenLogprobs$Outbound } from "./chatmessagetokenlogprobs.js";
+import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatResponseChoice = {
     finishReason: ChatCompletionFinishReason | null;
@@ -12,27 +12,5 @@ export type ChatResponseChoice = {
 };
 /** @internal */
 export declare const ChatResponseChoice$inboundSchema: z.ZodType<ChatResponseChoice, unknown>;
-/** @internal */
-export type ChatResponseChoice$Outbound = {
-    finish_reason: string | null;
-    index: number;
-    message: AssistantMessage$Outbound;
-    logprobs?: ChatMessageTokenLogprobs$Outbound | null | undefined;
-};
-/** @internal */
-export declare const ChatResponseChoice$outboundSchema: z.ZodType<ChatResponseChoice$Outbound, ChatResponseChoice>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatResponseChoice$ {
-    /** @deprecated use `ChatResponseChoice$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatResponseChoice, unknown, z.core.$ZodTypeInternals<ChatResponseChoice, unknown>>;
-    /** @deprecated use `ChatResponseChoice$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatResponseChoice$Outbound, ChatResponseChoice, z.core.$ZodTypeInternals<ChatResponseChoice$Outbound, ChatResponseChoice>>;
-    /** @deprecated use `ChatResponseChoice$Outbound` instead. */
-    type Outbound = ChatResponseChoice$Outbound;
-}
-export declare function chatResponseChoiceToJSON(chatResponseChoice: ChatResponseChoice): string;
 export declare function chatResponseChoiceFromJSON(jsonString: string): SafeParseResult<ChatResponseChoice, SDKValidationError>;
 //# sourceMappingURL=chatresponsechoice.d.ts.map

package/esm/models/chatresponsechoice.js

@@ -4,9 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { AssistantMessage$inboundSchema, AssistantMessage$outboundSchema, } from "./assistantmessage.js";
-import { ChatCompletionFinishReason$inboundSchema, ChatCompletionFinishReason$outboundSchema, } from "./chatcompletionfinishreason.js";
-import { ChatMessageTokenLogprobs$inboundSchema, ChatMessageTokenLogprobs$outboundSchema, } from "./chatmessagetokenlogprobs.js";
+import { AssistantMessage$inboundSchema, } from "./assistantmessage.js";
+import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
+import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
 /** @internal */
 export const ChatResponseChoice$inboundSchema = z.object({
     finish_reason: z.nullable(ChatCompletionFinishReason$inboundSchema),
@@ -18,31 +18,6 @@ export const ChatResponseChoice$inboundSchema = z.object({
         "finish_reason": "finishReason",
     });
 });
-/** @internal */
-export const ChatResponseChoice$outboundSchema = z.object({
-    finishReason: z.nullable(ChatCompletionFinishReason$outboundSchema),
-    index: z.number(),
-    message: AssistantMessage$outboundSchema,
-    logprobs: z.nullable(ChatMessageTokenLogprobs$outboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        finishReason: "finish_reason",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatResponseChoice$;
-(function (ChatResponseChoice$) {
-    /** @deprecated use `ChatResponseChoice$inboundSchema` instead. */
-    ChatResponseChoice$.inboundSchema = ChatResponseChoice$inboundSchema;
-    /** @deprecated use `ChatResponseChoice$outboundSchema` instead. */
-    ChatResponseChoice$.outboundSchema = ChatResponseChoice$outboundSchema;
-})(ChatResponseChoice$ || (ChatResponseChoice$ = {}));
-export function chatResponseChoiceToJSON(chatResponseChoice) {
-    return JSON.stringify(ChatResponseChoice$outboundSchema.parse(chatResponseChoice));
-}
 export function chatResponseChoiceFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatResponseChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatResponseChoice' from JSON`);
 }

package/esm/models/chatstreamingchoice.d.ts

@@ -1,8 +1,8 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { ChatCompletionFinishReason } from "./chatcompletionfinishreason.js";
-import { ChatMessageTokenLogprobs, ChatMessageTokenLogprobs$Outbound } from "./chatmessagetokenlogprobs.js";
-import { ChatStreamingMessageChunk, ChatStreamingMessageChunk$Outbound } from "./chatstreamingmessagechunk.js";
+import { ChatMessageTokenLogprobs } from "./chatmessagetokenlogprobs.js";
+import { ChatStreamingMessageChunk } from "./chatstreamingmessagechunk.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type ChatStreamingChoice = {
     delta: ChatStreamingMessageChunk;
@@ -12,27 +12,5 @@ export type ChatStreamingChoice = {
 };
 /** @internal */
 export declare const ChatStreamingChoice$inboundSchema: z.ZodType<ChatStreamingChoice, unknown>;
-/** @internal */
-export type ChatStreamingChoice$Outbound = {
-    delta: ChatStreamingMessageChunk$Outbound;
-    finish_reason: string | null;
-    index: number;
-    logprobs?: ChatMessageTokenLogprobs$Outbound | null | undefined;
-};
-/** @internal */
-export declare const ChatStreamingChoice$outboundSchema: z.ZodType<ChatStreamingChoice$Outbound, ChatStreamingChoice>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatStreamingChoice$ {
-    /** @deprecated use `ChatStreamingChoice$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatStreamingChoice, unknown, z.core.$ZodTypeInternals<ChatStreamingChoice, unknown>>;
-    /** @deprecated use `ChatStreamingChoice$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatStreamingChoice$Outbound, ChatStreamingChoice, z.core.$ZodTypeInternals<ChatStreamingChoice$Outbound, ChatStreamingChoice>>;
-    /** @deprecated use `ChatStreamingChoice$Outbound` instead. */
-    type Outbound = ChatStreamingChoice$Outbound;
-}
-export declare function chatStreamingChoiceToJSON(chatStreamingChoice: ChatStreamingChoice): string;
 export declare function chatStreamingChoiceFromJSON(jsonString: string): SafeParseResult<ChatStreamingChoice, SDKValidationError>;
 //# sourceMappingURL=chatstreamingchoice.d.ts.map

package/esm/models/chatstreamingchoice.js

@@ -4,9 +4,9 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ChatCompletionFinishReason$inboundSchema, ChatCompletionFinishReason$outboundSchema, } from "./chatcompletionfinishreason.js";
-import { ChatMessageTokenLogprobs$inboundSchema, ChatMessageTokenLogprobs$outboundSchema, } from "./chatmessagetokenlogprobs.js";
-import { ChatStreamingMessageChunk$inboundSchema, ChatStreamingMessageChunk$outboundSchema, } from "./chatstreamingmessagechunk.js";
+import { ChatCompletionFinishReason$inboundSchema, } from "./chatcompletionfinishreason.js";
+import { ChatMessageTokenLogprobs$inboundSchema, } from "./chatmessagetokenlogprobs.js";
+import { ChatStreamingMessageChunk$inboundSchema, } from "./chatstreamingmessagechunk.js";
 /** @internal */
 export const ChatStreamingChoice$inboundSchema = z.object({
     delta: ChatStreamingMessageChunk$inboundSchema,
@@ -18,31 +18,6 @@ export const ChatStreamingChoice$inboundSchema = z.object({
         "finish_reason": "finishReason",
     });
 });
-/** @internal */
-export const ChatStreamingChoice$outboundSchema = z.object({
-    delta: ChatStreamingMessageChunk$outboundSchema,
-    finishReason: z.nullable(ChatCompletionFinishReason$outboundSchema),
-    index: z.number(),
-    logprobs: z.nullable(ChatMessageTokenLogprobs$outboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        finishReason: "finish_reason",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatStreamingChoice$;
-(function (ChatStreamingChoice$) {
-    /** @deprecated use `ChatStreamingChoice$inboundSchema` instead. */
-    ChatStreamingChoice$.inboundSchema = ChatStreamingChoice$inboundSchema;
-    /** @deprecated use `ChatStreamingChoice$outboundSchema` instead. */
-    ChatStreamingChoice$.outboundSchema = ChatStreamingChoice$outboundSchema;
-})(ChatStreamingChoice$ || (ChatStreamingChoice$ = {}));
-export function chatStreamingChoiceToJSON(chatStreamingChoice) {
-    return JSON.stringify(ChatStreamingChoice$outboundSchema.parse(chatStreamingChoice));
-}
 export function chatStreamingChoiceFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatStreamingChoice$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingChoice' from JSON`);
 }

package/esm/models/chatstreamingmessagechunk.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { ChatStreamingMessageToolCall, ChatStreamingMessageToolCall$Outbound } from "./chatstreamingmessagetoolcall.js";
+import { ChatStreamingMessageToolCall } from "./chatstreamingmessagetoolcall.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export declare const ChatStreamingMessageChunkRole: {
     readonly Assistant: "assistant";
@@ -17,45 +17,6 @@ export type ChatStreamingMessageChunk = {
 /** @internal */
 export declare const ChatStreamingMessageChunkRole$inboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;
 /** @internal */
-export declare const ChatStreamingMessageChunkRole$outboundSchema: z.ZodEnum<typeof ChatStreamingMessageChunkRole>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatStreamingMessageChunkRole$ {
-    /** @deprecated use `ChatStreamingMessageChunkRole$inboundSchema` instead. */
-    const inboundSchema: z.ZodEnum<{
-        readonly Assistant: "assistant";
-    }>;
-    /** @deprecated use `ChatStreamingMessageChunkRole$outboundSchema` instead. */
-    const outboundSchema: z.ZodEnum<{
-        readonly Assistant: "assistant";
-    }>;
-}
-/** @internal */
 export declare const ChatStreamingMessageChunk$inboundSchema: z.ZodType<ChatStreamingMessageChunk, unknown>;
-/** @internal */
-export type ChatStreamingMessageChunk$Outbound = {
-    role?: string | undefined;
-    content?: string | null | undefined;
-    reasoning?: string | null | undefined;
-    refusal?: string | null | undefined;
-    tool_calls?: Array<ChatStreamingMessageToolCall$Outbound> | undefined;
-};
-/** @internal */
-export declare const ChatStreamingMessageChunk$outboundSchema: z.ZodType<ChatStreamingMessageChunk$Outbound, ChatStreamingMessageChunk>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatStreamingMessageChunk$ {
-    /** @deprecated use `ChatStreamingMessageChunk$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatStreamingMessageChunk, unknown, z.core.$ZodTypeInternals<ChatStreamingMessageChunk, unknown>>;
-    /** @deprecated use `ChatStreamingMessageChunk$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatStreamingMessageChunk$Outbound, ChatStreamingMessageChunk, z.core.$ZodTypeInternals<ChatStreamingMessageChunk$Outbound, ChatStreamingMessageChunk>>;
-    /** @deprecated use `ChatStreamingMessageChunk$Outbound` instead. */
-    type Outbound = ChatStreamingMessageChunk$Outbound;
-}
-export declare function chatStreamingMessageChunkToJSON(chatStreamingMessageChunk: ChatStreamingMessageChunk): string;
 export declare function chatStreamingMessageChunkFromJSON(jsonString: string): SafeParseResult<ChatStreamingMessageChunk, SDKValidationError>;
 //# sourceMappingURL=chatstreamingmessagechunk.d.ts.map

package/esm/models/chatstreamingmessagechunk.js

@@ -4,26 +4,13 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { ChatStreamingMessageToolCall$inboundSchema, ChatStreamingMessageToolCall$outboundSchema, } from "./chatstreamingmessagetoolcall.js";
+import { ChatStreamingMessageToolCall$inboundSchema, } from "./chatstreamingmessagetoolcall.js";
 export const ChatStreamingMessageChunkRole = {
     Assistant: "assistant",
 };
 /** @internal */
 export const ChatStreamingMessageChunkRole$inboundSchema = z.enum(ChatStreamingMessageChunkRole);
 /** @internal */
-export const ChatStreamingMessageChunkRole$outboundSchema = ChatStreamingMessageChunkRole$inboundSchema;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatStreamingMessageChunkRole$;
-(function (ChatStreamingMessageChunkRole$) {
-    /** @deprecated use `ChatStreamingMessageChunkRole$inboundSchema` instead. */
-    ChatStreamingMessageChunkRole$.inboundSchema = ChatStreamingMessageChunkRole$inboundSchema;
-    /** @deprecated use `ChatStreamingMessageChunkRole$outboundSchema` instead. */
-    ChatStreamingMessageChunkRole$.outboundSchema = ChatStreamingMessageChunkRole$outboundSchema;
-})(ChatStreamingMessageChunkRole$ || (ChatStreamingMessageChunkRole$ = {}));
-/** @internal */
 export const ChatStreamingMessageChunk$inboundSchema = z.object({
     role: ChatStreamingMessageChunkRole$inboundSchema.optional(),
     content: z.nullable(z.string()).optional(),
@@ -35,32 +22,6 @@ export const ChatStreamingMessageChunk$inboundSchema = z.object({
         "tool_calls": "toolCalls",
     });
 });
-/** @internal */
-export const ChatStreamingMessageChunk$outboundSchema = z.object({
-    role: ChatStreamingMessageChunkRole$outboundSchema.optional(),
-    content: z.nullable(z.string()).optional(),
-    reasoning: z.nullable(z.string()).optional(),
-    refusal: z.nullable(z.string()).optional(),
-    toolCalls: z.array(ChatStreamingMessageToolCall$outboundSchema).optional(),
-}).transform((v) => {
-    return remap$(v, {
-        toolCalls: "tool_calls",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ChatStreamingMessageChunk$;
-(function (ChatStreamingMessageChunk$) {
-    /** @deprecated use `ChatStreamingMessageChunk$inboundSchema` instead. */
-    ChatStreamingMessageChunk$.inboundSchema = ChatStreamingMessageChunk$inboundSchema;
-    /** @deprecated use `ChatStreamingMessageChunk$outboundSchema` instead. */
-    ChatStreamingMessageChunk$.outboundSchema = ChatStreamingMessageChunk$outboundSchema;
-})(ChatStreamingMessageChunk$ || (ChatStreamingMessageChunk$ = {}));
-export function chatStreamingMessageChunkToJSON(chatStreamingMessageChunk) {
-    return JSON.stringify(ChatStreamingMessageChunk$outboundSchema.parse(chatStreamingMessageChunk));
-}
 export function chatStreamingMessageChunkFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatStreamingMessageChunk$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingMessageChunk' from JSON`);
 }

package/esm/models/chatstreamingmessagetoolcall.d.ts

@@ -13,50 +13,8 @@ export type ChatStreamingMessageToolCall = {
 };
 /** @internal */
 export declare const ChatStreamingMessageToolCallFunction$inboundSchema: z.ZodType<ChatStreamingMessageToolCallFunction, unknown>;
-/** @internal */
-export type ChatStreamingMessageToolCallFunction$Outbound = {
-    name?: string | undefined;
-    arguments?: string | undefined;
-};
-/** @internal */
-export declare const ChatStreamingMessageToolCallFunction$outboundSchema: z.ZodType<ChatStreamingMessageToolCallFunction$Outbound, ChatStreamingMessageToolCallFunction>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatStreamingMessageToolCallFunction$ {
-    /** @deprecated use `ChatStreamingMessageToolCallFunction$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatStreamingMessageToolCallFunction, unknown, z.core.$ZodTypeInternals<ChatStreamingMessageToolCallFunction, unknown>>;
-    /** @deprecated use `ChatStreamingMessageToolCallFunction$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatStreamingMessageToolCallFunction$Outbound, ChatStreamingMessageToolCallFunction, z.core.$ZodTypeInternals<ChatStreamingMessageToolCallFunction$Outbound, ChatStreamingMessageToolCallFunction>>;
-    /** @deprecated use `ChatStreamingMessageToolCallFunction$Outbound` instead. */
-    type Outbound = ChatStreamingMessageToolCallFunction$Outbound;
-}
-export declare function chatStreamingMessageToolCallFunctionToJSON(chatStreamingMessageToolCallFunction: ChatStreamingMessageToolCallFunction): string;
 export declare function chatStreamingMessageToolCallFunctionFromJSON(jsonString: string): SafeParseResult<ChatStreamingMessageToolCallFunction, SDKValidationError>;
 /** @internal */
 export declare const ChatStreamingMessageToolCall$inboundSchema: z.ZodType<ChatStreamingMessageToolCall, unknown>;
-/** @internal */
-export type ChatStreamingMessageToolCall$Outbound = {
-    index: number;
-    id?: string | undefined;
-    type?: "function" | undefined;
-    function?: ChatStreamingMessageToolCallFunction$Outbound | undefined;
-};
-/** @internal */
-export declare const ChatStreamingMessageToolCall$outboundSchema: z.ZodType<ChatStreamingMessageToolCall$Outbound, ChatStreamingMessageToolCall>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ChatStreamingMessageToolCall$ {
-    /** @deprecated use `ChatStreamingMessageToolCall$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatStreamingMessageToolCall, unknown, z.core.$ZodTypeInternals<ChatStreamingMessageToolCall, unknown>>;
-    /** @deprecated use `ChatStreamingMessageToolCall$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatStreamingMessageToolCall$Outbound, ChatStreamingMessageToolCall, z.core.$ZodTypeInternals<ChatStreamingMessageToolCall$Outbound, ChatStreamingMessageToolCall>>;
-    /** @deprecated use `ChatStreamingMessageToolCall$Outbound` instead. */
-    type Outbound = ChatStreamingMessageToolCall$Outbound;
-}
-export declare function chatStreamingMessageToolCallToJSON(chatStreamingMessageToolCall: ChatStreamingMessageToolCall): string;
 export declare function chatStreamingMessageToolCallFromJSON(jsonString: string): SafeParseResult<ChatStreamingMessageToolCall, SDKValidationError>;
 //# sourceMappingURL=chatstreamingmessagetoolcall.d.ts.map