@openrouter/sdk 0.1.2 → 0.1.4

package/esm/models/internalserverresponseerrordata.d.ts

@@ -13,28 +13,5 @@ export type InternalServerResponseErrorData = {
 };
 /** @internal */
 export declare const InternalServerResponseErrorData$inboundSchema: z.ZodType<InternalServerResponseErrorData, unknown>;
-/** @internal */
-export type InternalServerResponseErrorData$Outbound = {
-    code: number;
-    message: string;
-    metadata?: {
-        [k: string]: any | null;
-    } | null | undefined;
-};
-/** @internal */
-export declare const InternalServerResponseErrorData$outboundSchema: z.ZodType<InternalServerResponseErrorData$Outbound, InternalServerResponseErrorData>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace InternalServerResponseErrorData$ {
-    /** @deprecated use `InternalServerResponseErrorData$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<InternalServerResponseErrorData, unknown, z.core.$ZodTypeInternals<InternalServerResponseErrorData, unknown>>;
-    /** @deprecated use `InternalServerResponseErrorData$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<InternalServerResponseErrorData$Outbound, InternalServerResponseErrorData, z.core.$ZodTypeInternals<InternalServerResponseErrorData$Outbound, InternalServerResponseErrorData>>;
-    /** @deprecated use `InternalServerResponseErrorData$Outbound` instead. */
-    type Outbound = InternalServerResponseErrorData$Outbound;
-}
-export declare function internalServerResponseErrorDataToJSON(internalServerResponseErrorData: InternalServerResponseErrorData): string;
 export declare function internalServerResponseErrorDataFromJSON(jsonString: string): SafeParseResult<InternalServerResponseErrorData, SDKValidationError>;
 //# sourceMappingURL=internalserverresponseerrordata.d.ts.map

package/esm/models/internalserverresponseerrordata.js

@@ -9,26 +9,6 @@ export const InternalServerResponseErrorData$inboundSchema = z.object({
     message: z.string(),
     metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
 });
-/** @internal */
-export const InternalServerResponseErrorData$outboundSchema = z.object({
-    code: z.number().int(),
-    message: z.string(),
-    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var InternalServerResponseErrorData$;
-(function (InternalServerResponseErrorData$) {
-    /** @deprecated use `InternalServerResponseErrorData$inboundSchema` instead. */
-    InternalServerResponseErrorData$.inboundSchema = InternalServerResponseErrorData$inboundSchema;
-    /** @deprecated use `InternalServerResponseErrorData$outboundSchema` instead. */
-    InternalServerResponseErrorData$.outboundSchema = InternalServerResponseErrorData$outboundSchema;
-})(InternalServerResponseErrorData$ || (InternalServerResponseErrorData$ = {}));
-export function internalServerResponseErrorDataToJSON(internalServerResponseErrorData) {
-    return JSON.stringify(InternalServerResponseErrorData$outboundSchema.parse(internalServerResponseErrorData));
-}
 export function internalServerResponseErrorDataFromJSON(jsonString) {
     return safeParse(jsonString, (x) => InternalServerResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'InternalServerResponseErrorData' from JSON`);
 }

package/esm/models/jsonschemaconfig.d.ts

@@ -1,6 +1,4 @@
 import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../types/fp.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export type JSONSchemaConfig = {
     name: string;
     description?: string | undefined;
@@ -10,8 +8,6 @@ export type JSONSchemaConfig = {
     strict?: boolean | null | undefined;
 };
 /** @internal */
-export declare const JSONSchemaConfig$inboundSchema: z.ZodType<JSONSchemaConfig, unknown>;
-/** @internal */
 export type JSONSchemaConfig$Outbound = {
     name: string;
     description?: string | undefined;
@@ -22,18 +18,5 @@ export type JSONSchemaConfig$Outbound = {
 };
 /** @internal */
 export declare const JSONSchemaConfig$outboundSchema: z.ZodType<JSONSchemaConfig$Outbound, JSONSchemaConfig>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace JSONSchemaConfig$ {
-    /** @deprecated use `JSONSchemaConfig$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<JSONSchemaConfig, unknown, z.core.$ZodTypeInternals<JSONSchemaConfig, unknown>>;
-    /** @deprecated use `JSONSchemaConfig$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<JSONSchemaConfig$Outbound, JSONSchemaConfig, z.core.$ZodTypeInternals<JSONSchemaConfig$Outbound, JSONSchemaConfig>>;
-    /** @deprecated use `JSONSchemaConfig$Outbound` instead. */
-    type Outbound = JSONSchemaConfig$Outbound;
-}
 export declare function jsonSchemaConfigToJSON(jsonSchemaConfig: JSONSchemaConfig): string;
-export declare function jsonSchemaConfigFromJSON(jsonString: string): SafeParseResult<JSONSchemaConfig, SDKValidationError>;
 //# sourceMappingURL=jsonschemaconfig.d.ts.map

package/esm/models/jsonschemaconfig.js

@@ -2,14 +2,6 @@
  * 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 JSONSchemaConfig$inboundSchema = z.object({
-    name: z.string(),
-    description: z.string().optional(),
-    schema: z.record(z.string(), z.any()).optional(),
-    strict: z.nullable(z.boolean()).optional(),
-});
 /** @internal */
 export const JSONSchemaConfig$outboundSchema = z.object({
     name: z.string(),
@@ -17,21 +9,7 @@ export const JSONSchemaConfig$outboundSchema = z.object({
     schema: z.record(z.string(), z.any()).optional(),
     strict: z.nullable(z.boolean()).optional(),
 });
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var JSONSchemaConfig$;
-(function (JSONSchemaConfig$) {
-    /** @deprecated use `JSONSchemaConfig$inboundSchema` instead. */
-    JSONSchemaConfig$.inboundSchema = JSONSchemaConfig$inboundSchema;
-    /** @deprecated use `JSONSchemaConfig$outboundSchema` instead. */
-    JSONSchemaConfig$.outboundSchema = JSONSchemaConfig$outboundSchema;
-})(JSONSchemaConfig$ || (JSONSchemaConfig$ = {}));
 export function jsonSchemaConfigToJSON(jsonSchemaConfig) {
     return JSON.stringify(JSONSchemaConfig$outboundSchema.parse(jsonSchemaConfig));
 }
-export function jsonSchemaConfigFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => JSONSchemaConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'JSONSchemaConfig' from JSON`);
-}
 //# sourceMappingURL=jsonschemaconfig.js.map

package/esm/models/listendpointsresponse.d.ts

@@ -5,7 +5,7 @@ import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { InputModality } from "./inputmodality.js";
 import { InstructType } from "./instructtype.js";
 import { OutputModality } from "./outputmodality.js";
-import { PublicEndpoint, PublicEndpoint$Outbound } from "./publicendpoint.js";
+import { PublicEndpoint } from "./publicendpoint.js";
 /**
  * Tokenizer type used by the model
  */
@@ -85,68 +85,9 @@ export type ListEndpointsResponse = {
 /** @internal */
 export declare const Tokenizer$inboundSchema: z.ZodType<Tokenizer, unknown>;
 /** @internal */
-export declare const Tokenizer$outboundSchema: z.ZodType<Tokenizer, Tokenizer>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace Tokenizer$ {
-    /** @deprecated use `Tokenizer$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Tokenizer, unknown, z.core.$ZodTypeInternals<Tokenizer, unknown>>;
-    /** @deprecated use `Tokenizer$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Tokenizer, Tokenizer, z.core.$ZodTypeInternals<Tokenizer, Tokenizer>>;
-}
-/** @internal */
 export declare const Architecture$inboundSchema: z.ZodType<Architecture, unknown>;
-/** @internal */
-export type Architecture$Outbound = {
-    tokenizer: string | null;
-    instruct_type: string | null;
-    modality: string | null;
-    input_modalities: Array<string>;
-    output_modalities: Array<string>;
-};
-/** @internal */
-export declare const Architecture$outboundSchema: z.ZodType<Architecture$Outbound, Architecture>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace Architecture$ {
-    /** @deprecated use `Architecture$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Architecture, unknown, z.core.$ZodTypeInternals<Architecture, unknown>>;
-    /** @deprecated use `Architecture$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Architecture$Outbound, Architecture, z.core.$ZodTypeInternals<Architecture$Outbound, Architecture>>;
-    /** @deprecated use `Architecture$Outbound` instead. */
-    type Outbound = Architecture$Outbound;
-}
-export declare function architectureToJSON(architecture: Architecture): string;
 export declare function architectureFromJSON(jsonString: string): SafeParseResult<Architecture, SDKValidationError>;
 /** @internal */
 export declare const ListEndpointsResponse$inboundSchema: z.ZodType<ListEndpointsResponse, unknown>;
-/** @internal */
-export type ListEndpointsResponse$Outbound = {
-    id: string;
-    name: string;
-    created: number;
-    description: string;
-    architecture: Architecture$Outbound;
-    endpoints: Array<PublicEndpoint$Outbound>;
-};
-/** @internal */
-export declare const ListEndpointsResponse$outboundSchema: z.ZodType<ListEndpointsResponse$Outbound, ListEndpointsResponse>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ListEndpointsResponse$ {
-    /** @deprecated use `ListEndpointsResponse$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ListEndpointsResponse, unknown, z.core.$ZodTypeInternals<ListEndpointsResponse, unknown>>;
-    /** @deprecated use `ListEndpointsResponse$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ListEndpointsResponse$Outbound, ListEndpointsResponse, z.core.$ZodTypeInternals<ListEndpointsResponse$Outbound, ListEndpointsResponse>>;
-    /** @deprecated use `ListEndpointsResponse$Outbound` instead. */
-    type Outbound = ListEndpointsResponse$Outbound;
-}
-export declare function listEndpointsResponseToJSON(listEndpointsResponse: ListEndpointsResponse): string;
 export declare function listEndpointsResponseFromJSON(jsonString: string): SafeParseResult<ListEndpointsResponse, SDKValidationError>;
 //# sourceMappingURL=listendpointsresponse.d.ts.map

package/esm/models/listendpointsresponse.js

@@ -4,11 +4,11 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { catchUnrecognizedEnum, } from "../types/enums.js";
-import { InputModality$inboundSchema, InputModality$outboundSchema, } from "./inputmodality.js";
-import { InstructType$inboundSchema, InstructType$outboundSchema, } from "./instructtype.js";
-import { OutputModality$inboundSchema, OutputModality$outboundSchema, } from "./outputmodality.js";
-import { PublicEndpoint$inboundSchema, PublicEndpoint$outboundSchema, } from "./publicendpoint.js";
+import { catchUnrecognizedEnum } from "../types/enums.js";
+import { InputModality$inboundSchema } from "./inputmodality.js";
+import { InstructType$inboundSchema } from "./instructtype.js";
+import { OutputModality$inboundSchema, } from "./outputmodality.js";
+import { PublicEndpoint$inboundSchema, } from "./publicendpoint.js";
 /**
  * Tokenizer type used by the model
  */
@@ -40,23 +40,6 @@ export const Tokenizer$inboundSchema = z
     z.string().transform(catchUnrecognizedEnum),
 ]);
 /** @internal */
-export const Tokenizer$outboundSchema = z
-    .union([
-    z.enum(Tokenizer),
-    z.string().and(z.custom()),
-]);
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var Tokenizer$;
-(function (Tokenizer$) {
-    /** @deprecated use `Tokenizer$inboundSchema` instead. */
-    Tokenizer$.inboundSchema = Tokenizer$inboundSchema;
-    /** @deprecated use `Tokenizer$outboundSchema` instead. */
-    Tokenizer$.outboundSchema = Tokenizer$outboundSchema;
-})(Tokenizer$ || (Tokenizer$ = {}));
-/** @internal */
 export const Architecture$inboundSchema = z
     .object({
     tokenizer: z.nullable(Tokenizer$inboundSchema),
@@ -71,34 +54,6 @@ export const Architecture$inboundSchema = z
         "output_modalities": "outputModalities",
     });
 });
-/** @internal */
-export const Architecture$outboundSchema = z.object({
-    tokenizer: z.nullable(Tokenizer$outboundSchema),
-    instructType: z.nullable(InstructType$outboundSchema),
-    modality: z.nullable(z.string()),
-    inputModalities: z.array(InputModality$outboundSchema),
-    outputModalities: z.array(OutputModality$outboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        instructType: "instruct_type",
-        inputModalities: "input_modalities",
-        outputModalities: "output_modalities",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var Architecture$;
-(function (Architecture$) {
-    /** @deprecated use `Architecture$inboundSchema` instead. */
-    Architecture$.inboundSchema = Architecture$inboundSchema;
-    /** @deprecated use `Architecture$outboundSchema` instead. */
-    Architecture$.outboundSchema = Architecture$outboundSchema;
-})(Architecture$ || (Architecture$ = {}));
-export function architectureToJSON(architecture) {
-    return JSON.stringify(Architecture$outboundSchema.parse(architecture));
-}
 export function architectureFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Architecture$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Architecture' from JSON`);
 }
@@ -111,29 +66,6 @@ export const ListEndpointsResponse$inboundSchema = z.object({
     architecture: z.lazy(() => Architecture$inboundSchema),
     endpoints: z.array(PublicEndpoint$inboundSchema),
 });
-/** @internal */
-export const ListEndpointsResponse$outboundSchema = z.object({
-    id: z.string(),
-    name: z.string(),
-    created: z.number(),
-    description: z.string(),
-    architecture: z.lazy(() => Architecture$outboundSchema),
-    endpoints: z.array(PublicEndpoint$outboundSchema),
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var ListEndpointsResponse$;
-(function (ListEndpointsResponse$) {
-    /** @deprecated use `ListEndpointsResponse$inboundSchema` instead. */
-    ListEndpointsResponse$.inboundSchema = ListEndpointsResponse$inboundSchema;
-    /** @deprecated use `ListEndpointsResponse$outboundSchema` instead. */
-    ListEndpointsResponse$.outboundSchema = ListEndpointsResponse$outboundSchema;
-})(ListEndpointsResponse$ || (ListEndpointsResponse$ = {}));
-export function listEndpointsResponseToJSON(listEndpointsResponse) {
-    return JSON.stringify(ListEndpointsResponse$outboundSchema.parse(listEndpointsResponse));
-}
 export function listEndpointsResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ListEndpointsResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ListEndpointsResponse' from JSON`);
 }

package/esm/models/message.d.ts

@@ -1,8 +1,6 @@
 import * as z from "zod/v4";
-import { Result as SafeParseResult } from "../types/fp.js";
 import { AssistantMessage, AssistantMessage$Outbound } from "./assistantmessage.js";
 import { ChatMessageContentItemText, ChatMessageContentItemText$Outbound } from "./chatmessagecontentitemtext.js";
-import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { SystemMessage, SystemMessage$Outbound } from "./systemmessage.js";
 import { ToolResponseMessage, ToolResponseMessage$Outbound } from "./toolresponsemessage.js";
 import { UserMessage, UserMessage$Outbound } from "./usermessage.js";
@@ -14,27 +12,10 @@ export type MessageDeveloper = {
 };
 export type Message = ToolResponseMessage | SystemMessage | UserMessage | MessageDeveloper | AssistantMessage;
 /** @internal */
-export declare const MessageContent$inboundSchema: z.ZodType<MessageContent, unknown>;
-/** @internal */
 export type MessageContent$Outbound = string | Array<ChatMessageContentItemText$Outbound>;
 /** @internal */
 export declare const MessageContent$outboundSchema: z.ZodType<MessageContent$Outbound, MessageContent>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace MessageContent$ {
-    /** @deprecated use `MessageContent$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<MessageContent, unknown, z.core.$ZodTypeInternals<MessageContent, unknown>>;
-    /** @deprecated use `MessageContent$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<MessageContent$Outbound, MessageContent, z.core.$ZodTypeInternals<MessageContent$Outbound, MessageContent>>;
-    /** @deprecated use `MessageContent$Outbound` instead. */
-    type Outbound = MessageContent$Outbound;
-}
 export declare function messageContentToJSON(messageContent: MessageContent): string;
-export declare function messageContentFromJSON(jsonString: string): SafeParseResult<MessageContent, SDKValidationError>;
-/** @internal */
-export declare const MessageDeveloper$inboundSchema: z.ZodType<MessageDeveloper, unknown>;
 /** @internal */
 export type MessageDeveloper$Outbound = {
     role: "developer";
@@ -43,38 +24,10 @@ export type MessageDeveloper$Outbound = {
 };
 /** @internal */
 export declare const MessageDeveloper$outboundSchema: z.ZodType<MessageDeveloper$Outbound, MessageDeveloper>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace MessageDeveloper$ {
-    /** @deprecated use `MessageDeveloper$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<MessageDeveloper, unknown, z.core.$ZodTypeInternals<MessageDeveloper, unknown>>;
-    /** @deprecated use `MessageDeveloper$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<MessageDeveloper$Outbound, MessageDeveloper, z.core.$ZodTypeInternals<MessageDeveloper$Outbound, MessageDeveloper>>;
-    /** @deprecated use `MessageDeveloper$Outbound` instead. */
-    type Outbound = MessageDeveloper$Outbound;
-}
 export declare function messageDeveloperToJSON(messageDeveloper: MessageDeveloper): string;
-export declare function messageDeveloperFromJSON(jsonString: string): SafeParseResult<MessageDeveloper, SDKValidationError>;
-/** @internal */
-export declare const Message$inboundSchema: z.ZodType<Message, unknown>;
 /** @internal */
 export type Message$Outbound = ToolResponseMessage$Outbound | SystemMessage$Outbound | UserMessage$Outbound | MessageDeveloper$Outbound | AssistantMessage$Outbound;
 /** @internal */
 export declare const Message$outboundSchema: z.ZodType<Message$Outbound, Message>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace Message$ {
-    /** @deprecated use `Message$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Message, unknown, z.core.$ZodTypeInternals<Message, unknown>>;
-    /** @deprecated use `Message$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Message$Outbound, Message, z.core.$ZodTypeInternals<Message$Outbound, Message>>;
-    /** @deprecated use `Message$Outbound` instead. */
-    type Outbound = Message$Outbound;
-}
 export declare function messageToJSON(message: Message): string;
-export declare function messageFromJSON(jsonString: string): SafeParseResult<Message, SDKValidationError>;
 //# sourceMappingURL=message.d.ts.map

package/esm/models/message.js

@@ -2,42 +2,16 @@
  * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
  */
 import * as z from "zod/v4";
-import { safeParse } from "../lib/schemas.js";
-import { AssistantMessage$inboundSchema, AssistantMessage$outboundSchema, } from "./assistantmessage.js";
-import { ChatMessageContentItemText$inboundSchema, ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
-import { SystemMessage$inboundSchema, SystemMessage$outboundSchema, } from "./systemmessage.js";
-import { ToolResponseMessage$inboundSchema, ToolResponseMessage$outboundSchema, } from "./toolresponsemessage.js";
-import { UserMessage$inboundSchema, UserMessage$outboundSchema, } from "./usermessage.js";
-/** @internal */
-export const MessageContent$inboundSchema = z.union([z.string(), z.array(ChatMessageContentItemText$inboundSchema)]);
+import { AssistantMessage$outboundSchema, } from "./assistantmessage.js";
+import { ChatMessageContentItemText$outboundSchema, } from "./chatmessagecontentitemtext.js";
+import { SystemMessage$outboundSchema, } from "./systemmessage.js";
+import { ToolResponseMessage$outboundSchema, } from "./toolresponsemessage.js";
+import { UserMessage$outboundSchema, } from "./usermessage.js";
 /** @internal */
 export const MessageContent$outboundSchema = z.union([z.string(), z.array(ChatMessageContentItemText$outboundSchema)]);
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var MessageContent$;
-(function (MessageContent$) {
-    /** @deprecated use `MessageContent$inboundSchema` instead. */
-    MessageContent$.inboundSchema = MessageContent$inboundSchema;
-    /** @deprecated use `MessageContent$outboundSchema` instead. */
-    MessageContent$.outboundSchema = MessageContent$outboundSchema;
-})(MessageContent$ || (MessageContent$ = {}));
 export function messageContentToJSON(messageContent) {
     return JSON.stringify(MessageContent$outboundSchema.parse(messageContent));
 }
-export function messageContentFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => MessageContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'MessageContent' from JSON`);
-}
-/** @internal */
-export const MessageDeveloper$inboundSchema = z.object({
-    role: z.literal("developer"),
-    content: z.union([
-        z.string(),
-        z.array(ChatMessageContentItemText$inboundSchema),
-    ]),
-    name: z.string().optional(),
-});
 /** @internal */
 export const MessageDeveloper$outboundSchema = z.object({
     role: z.literal("developer"),
@@ -47,31 +21,9 @@ export const MessageDeveloper$outboundSchema = z.object({
     ]),
     name: 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 var MessageDeveloper$;
-(function (MessageDeveloper$) {
-    /** @deprecated use `MessageDeveloper$inboundSchema` instead. */
-    MessageDeveloper$.inboundSchema = MessageDeveloper$inboundSchema;
-    /** @deprecated use `MessageDeveloper$outboundSchema` instead. */
-    MessageDeveloper$.outboundSchema = MessageDeveloper$outboundSchema;
-})(MessageDeveloper$ || (MessageDeveloper$ = {}));
 export function messageDeveloperToJSON(messageDeveloper) {
     return JSON.stringify(MessageDeveloper$outboundSchema.parse(messageDeveloper));
 }
-export function messageDeveloperFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => MessageDeveloper$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'MessageDeveloper' from JSON`);
-}
-/** @internal */
-export const Message$inboundSchema = z.union([
-    ToolResponseMessage$inboundSchema,
-    SystemMessage$inboundSchema,
-    UserMessage$inboundSchema,
-    z.lazy(() => MessageDeveloper$inboundSchema),
-    AssistantMessage$inboundSchema,
-]);
 /** @internal */
 export const Message$outboundSchema = z
     .union([
@@ -81,21 +33,7 @@ export const Message$outboundSchema = z
     z.lazy(() => MessageDeveloper$outboundSchema),
     AssistantMessage$outboundSchema,
 ]);
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var Message$;
-(function (Message$) {
-    /** @deprecated use `Message$inboundSchema` instead. */
-    Message$.inboundSchema = Message$inboundSchema;
-    /** @deprecated use `Message$outboundSchema` instead. */
-    Message$.outboundSchema = Message$outboundSchema;
-})(Message$ || (Message$ = {}));
 export function messageToJSON(message) {
     return JSON.stringify(Message$outboundSchema.parse(message));
 }
-export function messageFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Message$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Message' from JSON`);
-}
 //# sourceMappingURL=message.js.map

package/esm/models/model.d.ts

@@ -1,12 +1,12 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
-import { DefaultParameters, DefaultParameters$Outbound } from "./defaultparameters.js";
+import { DefaultParameters } from "./defaultparameters.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-import { ModelArchitecture, ModelArchitecture$Outbound } from "./modelarchitecture.js";
+import { ModelArchitecture } from "./modelarchitecture.js";
 import { Parameter } from "./parameter.js";
-import { PerRequestLimits, PerRequestLimits$Outbound } from "./perrequestlimits.js";
-import { PublicPricing, PublicPricing$Outbound } from "./publicpricing.js";
-import { TopProviderInfo, TopProviderInfo$Outbound } from "./topproviderinfo.js";
+import { PerRequestLimits } from "./perrequestlimits.js";
+import { PublicPricing } from "./publicpricing.js";
+import { TopProviderInfo } from "./topproviderinfo.js";
 /**
  * Information about an AI model available on OpenRouter
  */
@@ -66,36 +66,5 @@ export type Model = {
 };
 /** @internal */
 export declare const Model$inboundSchema: z.ZodType<Model, unknown>;
-/** @internal */
-export type Model$Outbound = {
-    id: string;
-    canonical_slug: string;
-    hugging_face_id?: string | null | undefined;
-    name: string;
-    created: number;
-    description?: string | undefined;
-    pricing: PublicPricing$Outbound;
-    context_length: number | null;
-    architecture: ModelArchitecture$Outbound;
-    top_provider: TopProviderInfo$Outbound;
-    per_request_limits: PerRequestLimits$Outbound | null;
-    supported_parameters: Array<string>;
-    default_parameters: DefaultParameters$Outbound | null;
-};
-/** @internal */
-export declare const Model$outboundSchema: z.ZodType<Model$Outbound, Model>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace Model$ {
-    /** @deprecated use `Model$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Model, unknown, z.core.$ZodTypeInternals<Model, unknown>>;
-    /** @deprecated use `Model$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Model$Outbound, Model, z.core.$ZodTypeInternals<Model$Outbound, Model>>;
-    /** @deprecated use `Model$Outbound` instead. */
-    type Outbound = Model$Outbound;
-}
-export declare function modelToJSON(model: Model): string;
 export declare function modelFromJSON(jsonString: string): SafeParseResult<Model, SDKValidationError>;
 //# sourceMappingURL=model.d.ts.map

package/esm/models/model.js

@@ -4,12 +4,12 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import { DefaultParameters$inboundSchema, DefaultParameters$outboundSchema, } from "./defaultparameters.js";
-import { ModelArchitecture$inboundSchema, ModelArchitecture$outboundSchema, } from "./modelarchitecture.js";
-import { Parameter$inboundSchema, Parameter$outboundSchema, } from "./parameter.js";
-import { PerRequestLimits$inboundSchema, PerRequestLimits$outboundSchema, } from "./perrequestlimits.js";
-import { PublicPricing$inboundSchema, PublicPricing$outboundSchema, } from "./publicpricing.js";
-import { TopProviderInfo$inboundSchema, TopProviderInfo$outboundSchema, } from "./topproviderinfo.js";
+import { DefaultParameters$inboundSchema, } from "./defaultparameters.js";
+import { ModelArchitecture$inboundSchema, } from "./modelarchitecture.js";
+import { Parameter$inboundSchema } from "./parameter.js";
+import { PerRequestLimits$inboundSchema, } from "./perrequestlimits.js";
+import { PublicPricing$inboundSchema } from "./publicpricing.js";
+import { TopProviderInfo$inboundSchema, } from "./topproviderinfo.js";
 /** @internal */
 export const Model$inboundSchema = z.object({
     id: z.string(),
@@ -36,46 +36,6 @@ export const Model$inboundSchema = z.object({
         "default_parameters": "defaultParameters",
     });
 });
-/** @internal */
-export const Model$outboundSchema = z.object({
-    id: z.string(),
-    canonicalSlug: z.string(),
-    huggingFaceId: z.nullable(z.string()).optional(),
-    name: z.string(),
-    created: z.number(),
-    description: z.string().optional(),
-    pricing: PublicPricing$outboundSchema,
-    contextLength: z.nullable(z.number()),
-    architecture: ModelArchitecture$outboundSchema,
-    topProvider: TopProviderInfo$outboundSchema,
-    perRequestLimits: z.nullable(PerRequestLimits$outboundSchema),
-    supportedParameters: z.array(Parameter$outboundSchema),
-    defaultParameters: z.nullable(DefaultParameters$outboundSchema),
-}).transform((v) => {
-    return remap$(v, {
-        canonicalSlug: "canonical_slug",
-        huggingFaceId: "hugging_face_id",
-        contextLength: "context_length",
-        topProvider: "top_provider",
-        perRequestLimits: "per_request_limits",
-        supportedParameters: "supported_parameters",
-        defaultParameters: "default_parameters",
-    });
-});
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export var Model$;
-(function (Model$) {
-    /** @deprecated use `Model$inboundSchema` instead. */
-    Model$.inboundSchema = Model$inboundSchema;
-    /** @deprecated use `Model$outboundSchema` instead. */
-    Model$.outboundSchema = Model$outboundSchema;
-})(Model$ || (Model$ = {}));
-export function modelToJSON(model) {
-    return JSON.stringify(Model$outboundSchema.parse(model));
-}
 export function modelFromJSON(jsonString) {
     return safeParse(jsonString, (x) => Model$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Model' from JSON`);
 }

package/esm/models/modelarchitecture.d.ts

@@ -64,41 +64,6 @@ export type ModelArchitecture = {
 /** @internal */
 export declare const ModelArchitectureInstructType$inboundSchema: z.ZodType<ModelArchitectureInstructType, unknown>;
 /** @internal */
-export declare const ModelArchitectureInstructType$outboundSchema: z.ZodType<ModelArchitectureInstructType, ModelArchitectureInstructType>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ModelArchitectureInstructType$ {
-    /** @deprecated use `ModelArchitectureInstructType$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ModelArchitectureInstructType, unknown, z.core.$ZodTypeInternals<ModelArchitectureInstructType, unknown>>;
-    /** @deprecated use `ModelArchitectureInstructType$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ModelArchitectureInstructType, ModelArchitectureInstructType, z.core.$ZodTypeInternals<ModelArchitectureInstructType, ModelArchitectureInstructType>>;
-}
-/** @internal */
 export declare const ModelArchitecture$inboundSchema: z.ZodType<ModelArchitecture, unknown>;
-/** @internal */
-export type ModelArchitecture$Outbound = {
-    tokenizer?: string | undefined;
-    instruct_type?: string | null | undefined;
-    modality: string | null;
-    input_modalities: Array<string>;
-    output_modalities: Array<string>;
-};
-/** @internal */
-export declare const ModelArchitecture$outboundSchema: z.ZodType<ModelArchitecture$Outbound, ModelArchitecture>;
-/**
- * @internal
- * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
- */
-export declare namespace ModelArchitecture$ {
-    /** @deprecated use `ModelArchitecture$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ModelArchitecture, unknown, z.core.$ZodTypeInternals<ModelArchitecture, unknown>>;
-    /** @deprecated use `ModelArchitecture$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ModelArchitecture$Outbound, ModelArchitecture, z.core.$ZodTypeInternals<ModelArchitecture$Outbound, ModelArchitecture>>;
-    /** @deprecated use `ModelArchitecture$Outbound` instead. */
-    type Outbound = ModelArchitecture$Outbound;
-}
-export declare function modelArchitectureToJSON(modelArchitecture: ModelArchitecture): string;
 export declare function modelArchitectureFromJSON(jsonString: string): SafeParseResult<ModelArchitecture, SDKValidationError>;
 //# sourceMappingURL=modelarchitecture.d.ts.map