@openrouter/sdk 0.0.1-beta.11 → 0.0.1-beta.12

package/esm/models/listendpointsresponse.d.ts

@@ -1,14 +1,138 @@
 import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
 import { Result as SafeParseResult } from "../types/fp.js";
 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";
+/**
+ * Tokenizer type used by the model
+ */
+export declare const Tokenizer: {
+    readonly Router: "Router";
+    readonly Media: "Media";
+    readonly Other: "Other";
+    readonly Gpt: "GPT";
+    readonly Claude: "Claude";
+    readonly Gemini: "Gemini";
+    readonly Grok: "Grok";
+    readonly Cohere: "Cohere";
+    readonly Nova: "Nova";
+    readonly Qwen: "Qwen";
+    readonly Yi: "Yi";
+    readonly DeepSeek: "DeepSeek";
+    readonly Mistral: "Mistral";
+    readonly Llama2: "Llama2";
+    readonly Llama3: "Llama3";
+    readonly Llama4: "Llama4";
+    readonly PaLM: "PaLM";
+    readonly Rwkv: "RWKV";
+    readonly Qwen3: "Qwen3";
+};
+/**
+ * Tokenizer type used by the model
+ */
+export type Tokenizer = OpenEnum<typeof Tokenizer>;
+/**
+ * Model architecture information
+ */
+export type Architecture = {
+    tokenizer: Tokenizer | null;
+    /**
+     * Instruction format type
+     */
+    instructType: InstructType | null;
+    /**
+     * Primary modality of the model
+     */
+    modality: string | null;
+    /**
+     * Supported input modalities
+     */
+    inputModalities: Array<InputModality>;
+    /**
+     * Supported output modalities
+     */
+    outputModalities: Array<OutputModality>;
+};
 /**
  * List of available endpoints for a model
  */
-export type ListEndpointsResponse = {};
+export type ListEndpointsResponse = {
+    /**
+     * Unique identifier for the model
+     */
+    id: string;
+    /**
+     * Display name of the model
+     */
+    name: string;
+    /**
+     * Unix timestamp of when the model was created
+     */
+    created: number;
+    /**
+     * Description of the model
+     */
+    description: string;
+    architecture: Architecture;
+    /**
+     * List of available endpoints for this model
+     */
+    endpoints: Array<PublicEndpoint>;
+};
+/** @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 = {};
+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>;
 /**

package/esm/models/listendpointsresponse.js

@@ -2,11 +2,124 @@
  * 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";
+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";
+/**
+ * Tokenizer type used by the model
+ */
+export const Tokenizer = {
+    Router: "Router",
+    Media: "Media",
+    Other: "Other",
+    Gpt: "GPT",
+    Claude: "Claude",
+    Gemini: "Gemini",
+    Grok: "Grok",
+    Cohere: "Cohere",
+    Nova: "Nova",
+    Qwen: "Qwen",
+    Yi: "Yi",
+    DeepSeek: "DeepSeek",
+    Mistral: "Mistral",
+    Llama2: "Llama2",
+    Llama3: "Llama3",
+    Llama4: "Llama4",
+    PaLM: "PaLM",
+    Rwkv: "RWKV",
+    Qwen3: "Qwen3",
+};
+/** @internal */
+export const Tokenizer$inboundSchema = z
+    .union([
+    z.enum(Tokenizer),
+    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),
+    instruct_type: z.nullable(InstructType$inboundSchema),
+    modality: z.nullable(z.string()),
+    input_modalities: z.array(InputModality$inboundSchema),
+    output_modalities: z.array(OutputModality$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "instruct_type": "instructType",
+        "input_modalities": "inputModalities",
+        "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`);
+}
 /** @internal */
-export const ListEndpointsResponse$inboundSchema = z.object({});
+export const ListEndpointsResponse$inboundSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    created: z.number(),
+    description: z.string(),
+    architecture: z.lazy(() => Architecture$inboundSchema),
+    endpoints: z.array(PublicEndpoint$inboundSchema),
+});
 /** @internal */
-export const ListEndpointsResponse$outboundSchema = z.object({});
+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.

package/esm/models/model.d.ts

@@ -0,0 +1,101 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { DefaultParameters, DefaultParameters$Outbound } from "./defaultparameters.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ModelArchitecture, ModelArchitecture$Outbound } 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";
+/**
+ * Information about an AI model available on OpenRouter
+ */
+export type Model = {
+    /**
+     * Unique identifier for the model
+     */
+    id: string;
+    /**
+     * Canonical slug for the model
+     */
+    canonicalSlug: string;
+    /**
+     * Hugging Face model identifier, if applicable
+     */
+    huggingFaceId?: string | null | undefined;
+    /**
+     * Display name of the model
+     */
+    name: string;
+    /**
+     * Unix timestamp of when the model was created
+     */
+    created: number;
+    /**
+     * Description of the model
+     */
+    description?: string | undefined;
+    /**
+     * Pricing information for the model
+     */
+    pricing: PublicPricing;
+    /**
+     * Maximum context length in tokens
+     */
+    contextLength: number | null;
+    /**
+     * Model architecture information
+     */
+    architecture: ModelArchitecture;
+    /**
+     * Information about the top provider for this model
+     */
+    topProvider: TopProviderInfo;
+    /**
+     * Per-request token limits
+     */
+    perRequestLimits: PerRequestLimits | null;
+    /**
+     * List of supported parameters for this model
+     */
+    supportedParameters: Array<Parameter>;
+    /**
+     * Default parameters for this model
+     */
+    defaultParameters: DefaultParameters | null;
+};
+/** @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

@@ -0,0 +1,82 @@
+/*
+ * 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";
+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";
+/** @internal */
+export const Model$inboundSchema = z.object({
+    id: z.string(),
+    canonical_slug: z.string(),
+    hugging_face_id: z.nullable(z.string()).optional(),
+    name: z.string(),
+    created: z.number(),
+    description: z.string().optional(),
+    pricing: PublicPricing$inboundSchema,
+    context_length: z.nullable(z.number()),
+    architecture: ModelArchitecture$inboundSchema,
+    top_provider: TopProviderInfo$inboundSchema,
+    per_request_limits: z.nullable(PerRequestLimits$inboundSchema),
+    supported_parameters: z.array(Parameter$inboundSchema),
+    default_parameters: z.nullable(DefaultParameters$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "canonical_slug": "canonicalSlug",
+        "hugging_face_id": "huggingFaceId",
+        "context_length": "contextLength",
+        "top_provider": "topProvider",
+        "per_request_limits": "perRequestLimits",
+        "supported_parameters": "supportedParameters",
+        "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`);
+}
+//# sourceMappingURL=model.js.map

package/esm/models/modelarchitecture.d.ts

@@ -0,0 +1,104 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { InputModality } from "./inputmodality.js";
+import { ModelGroup } from "./modelgroup.js";
+import { OutputModality } from "./outputmodality.js";
+/**
+ * Instruction format type
+ */
+export declare const ModelArchitectureInstructType: {
+    readonly None: "none";
+    readonly Airoboros: "airoboros";
+    readonly Alpaca: "alpaca";
+    readonly AlpacaModif: "alpaca-modif";
+    readonly Chatml: "chatml";
+    readonly Claude: "claude";
+    readonly CodeLlama: "code-llama";
+    readonly Gemma: "gemma";
+    readonly Llama2: "llama2";
+    readonly Llama3: "llama3";
+    readonly Mistral: "mistral";
+    readonly Nemotron: "nemotron";
+    readonly Neural: "neural";
+    readonly Openchat: "openchat";
+    readonly Phi3: "phi3";
+    readonly Rwkv: "rwkv";
+    readonly Vicuna: "vicuna";
+    readonly Zephyr: "zephyr";
+    readonly DeepseekR1: "deepseek-r1";
+    readonly DeepseekV31: "deepseek-v3.1";
+    readonly Qwq: "qwq";
+    readonly Qwen3: "qwen3";
+};
+/**
+ * Instruction format type
+ */
+export type ModelArchitectureInstructType = OpenEnum<typeof ModelArchitectureInstructType>;
+/**
+ * Model architecture information
+ */
+export type ModelArchitecture = {
+    /**
+     * Tokenizer type used by the model
+     */
+    tokenizer?: ModelGroup | undefined;
+    /**
+     * Instruction format type
+     */
+    instructType?: ModelArchitectureInstructType | null | undefined;
+    /**
+     * Primary modality of the model
+     */
+    modality: string | null;
+    /**
+     * Supported input modalities
+     */
+    inputModalities: Array<InputModality>;
+    /**
+     * Supported output modalities
+     */
+    outputModalities: Array<OutputModality>;
+};
+/** @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

package/esm/models/modelarchitecture.js

@@ -0,0 +1,107 @@
+/*
+ * 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";
+import { catchUnrecognizedEnum, } from "../types/enums.js";
+import { InputModality$inboundSchema, InputModality$outboundSchema, } from "./inputmodality.js";
+import { ModelGroup$inboundSchema, ModelGroup$outboundSchema, } from "./modelgroup.js";
+import { OutputModality$inboundSchema, OutputModality$outboundSchema, } from "./outputmodality.js";
+/**
+ * Instruction format type
+ */
+export const ModelArchitectureInstructType = {
+    None: "none",
+    Airoboros: "airoboros",
+    Alpaca: "alpaca",
+    AlpacaModif: "alpaca-modif",
+    Chatml: "chatml",
+    Claude: "claude",
+    CodeLlama: "code-llama",
+    Gemma: "gemma",
+    Llama2: "llama2",
+    Llama3: "llama3",
+    Mistral: "mistral",
+    Nemotron: "nemotron",
+    Neural: "neural",
+    Openchat: "openchat",
+    Phi3: "phi3",
+    Rwkv: "rwkv",
+    Vicuna: "vicuna",
+    Zephyr: "zephyr",
+    DeepseekR1: "deepseek-r1",
+    DeepseekV31: "deepseek-v3.1",
+    Qwq: "qwq",
+    Qwen3: "qwen3",
+};
+/** @internal */
+export const ModelArchitectureInstructType$inboundSchema = z
+    .union([
+    z.enum(ModelArchitectureInstructType),
+    z.string().transform(catchUnrecognizedEnum),
+]);
+/** @internal */
+export const ModelArchitectureInstructType$outboundSchema = z.union([
+    z.enum(ModelArchitectureInstructType),
+    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 ModelArchitectureInstructType$;
+(function (ModelArchitectureInstructType$) {
+    /** @deprecated use `ModelArchitectureInstructType$inboundSchema` instead. */
+    ModelArchitectureInstructType$.inboundSchema = ModelArchitectureInstructType$inboundSchema;
+    /** @deprecated use `ModelArchitectureInstructType$outboundSchema` instead. */
+    ModelArchitectureInstructType$.outboundSchema = ModelArchitectureInstructType$outboundSchema;
+})(ModelArchitectureInstructType$ || (ModelArchitectureInstructType$ = {}));
+/** @internal */
+export const ModelArchitecture$inboundSchema = z.object({
+    tokenizer: ModelGroup$inboundSchema.optional(),
+    instruct_type: z.nullable(ModelArchitectureInstructType$inboundSchema)
+        .optional(),
+    modality: z.nullable(z.string()),
+    input_modalities: z.array(InputModality$inboundSchema),
+    output_modalities: z.array(OutputModality$inboundSchema),
+}).transform((v) => {
+    return remap$(v, {
+        "instruct_type": "instructType",
+        "input_modalities": "inputModalities",
+        "output_modalities": "outputModalities",
+    });
+});
+/** @internal */
+export const ModelArchitecture$outboundSchema = z.object({
+    tokenizer: ModelGroup$outboundSchema.optional(),
+    instructType: z.nullable(ModelArchitectureInstructType$outboundSchema)
+        .optional(),
+    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 ModelArchitecture$;
+(function (ModelArchitecture$) {
+    /** @deprecated use `ModelArchitecture$inboundSchema` instead. */
+    ModelArchitecture$.inboundSchema = ModelArchitecture$inboundSchema;
+    /** @deprecated use `ModelArchitecture$outboundSchema` instead. */
+    ModelArchitecture$.outboundSchema = ModelArchitecture$outboundSchema;
+})(ModelArchitecture$ || (ModelArchitecture$ = {}));
+export function modelArchitectureToJSON(modelArchitecture) {
+    return JSON.stringify(ModelArchitecture$outboundSchema.parse(modelArchitecture));
+}
+export function modelArchitectureFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ModelArchitecture$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ModelArchitecture' from JSON`);
+}
+//# sourceMappingURL=modelarchitecture.js.map