@openrouter/sdk 0.0.1-beta.9 → 0.1.0

package/esm/models/chatmessagetokenlogprob.d.ts

@@ -1,7 +1,7 @@
 import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
-export type ChatMessageTokenLogprobTopLogprob = {
+export type TopLogprob = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
@@ -10,32 +10,32 @@ export type ChatMessageTokenLogprob = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
-    topLogprobs: Array<ChatMessageTokenLogprobTopLogprob>;
+    topLogprobs: Array<TopLogprob>;
 };
 /** @internal */
-export declare const ChatMessageTokenLogprobTopLogprob$inboundSchema: z.ZodType<ChatMessageTokenLogprobTopLogprob, unknown>;
+export declare const TopLogprob$inboundSchema: z.ZodType<TopLogprob, unknown>;
 /** @internal */
-export type ChatMessageTokenLogprobTopLogprob$Outbound = {
+export type TopLogprob$Outbound = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
 };
 /** @internal */
-export declare const ChatMessageTokenLogprobTopLogprob$outboundSchema: z.ZodType<ChatMessageTokenLogprobTopLogprob$Outbound, ChatMessageTokenLogprobTopLogprob>;
+export declare const TopLogprob$outboundSchema: z.ZodType<TopLogprob$Outbound, TopLogprob>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace ChatMessageTokenLogprobTopLogprob$ {
-    /** @deprecated use `ChatMessageTokenLogprobTopLogprob$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<ChatMessageTokenLogprobTopLogprob, unknown, z.core.$ZodTypeInternals<ChatMessageTokenLogprobTopLogprob, unknown>>;
-    /** @deprecated use `ChatMessageTokenLogprobTopLogprob$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<ChatMessageTokenLogprobTopLogprob$Outbound, ChatMessageTokenLogprobTopLogprob, z.core.$ZodTypeInternals<ChatMessageTokenLogprobTopLogprob$Outbound, ChatMessageTokenLogprobTopLogprob>>;
-    /** @deprecated use `ChatMessageTokenLogprobTopLogprob$Outbound` instead. */
-    type Outbound = ChatMessageTokenLogprobTopLogprob$Outbound;
+export declare namespace TopLogprob$ {
+    /** @deprecated use `TopLogprob$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<TopLogprob, unknown, z.core.$ZodTypeInternals<TopLogprob, unknown>>;
+    /** @deprecated use `TopLogprob$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<TopLogprob$Outbound, TopLogprob, z.core.$ZodTypeInternals<TopLogprob$Outbound, TopLogprob>>;
+    /** @deprecated use `TopLogprob$Outbound` instead. */
+    type Outbound = TopLogprob$Outbound;
 }
-export declare function chatMessageTokenLogprobTopLogprobToJSON(chatMessageTokenLogprobTopLogprob: ChatMessageTokenLogprobTopLogprob): string;
-export declare function chatMessageTokenLogprobTopLogprobFromJSON(jsonString: string): SafeParseResult<ChatMessageTokenLogprobTopLogprob, SDKValidationError>;
+export declare function topLogprobToJSON(topLogprob: TopLogprob): string;
+export declare function topLogprobFromJSON(jsonString: string): SafeParseResult<TopLogprob, SDKValidationError>;
 /** @internal */
 export declare const ChatMessageTokenLogprob$inboundSchema: z.ZodType<ChatMessageTokenLogprob, unknown>;
 /** @internal */
@@ -43,7 +43,7 @@ export type ChatMessageTokenLogprob$Outbound = {
     token: string;
     logprob: number;
     bytes: Array<number> | null;
-    top_logprobs: Array<ChatMessageTokenLogprobTopLogprob$Outbound>;
+    top_logprobs: Array<TopLogprob$Outbound>;
 };
 /** @internal */
 export declare const ChatMessageTokenLogprob$outboundSchema: z.ZodType<ChatMessageTokenLogprob$Outbound, ChatMessageTokenLogprob>;

package/esm/models/chatmessagetokenlogprob.js

@@ -5,13 +5,14 @@ import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 /** @internal */
-export const ChatMessageTokenLogprobTopLogprob$inboundSchema = z.object({
+export const TopLogprob$inboundSchema = z
+    .object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
 });
 /** @internal */
-export const ChatMessageTokenLogprobTopLogprob$outboundSchema = z.object({
+export const TopLogprob$outboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
@@ -20,25 +21,25 @@ export const ChatMessageTokenLogprobTopLogprob$outboundSchema = z.object({
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var ChatMessageTokenLogprobTopLogprob$;
-(function (ChatMessageTokenLogprobTopLogprob$) {
-    /** @deprecated use `ChatMessageTokenLogprobTopLogprob$inboundSchema` instead. */
-    ChatMessageTokenLogprobTopLogprob$.inboundSchema = ChatMessageTokenLogprobTopLogprob$inboundSchema;
-    /** @deprecated use `ChatMessageTokenLogprobTopLogprob$outboundSchema` instead. */
-    ChatMessageTokenLogprobTopLogprob$.outboundSchema = ChatMessageTokenLogprobTopLogprob$outboundSchema;
-})(ChatMessageTokenLogprobTopLogprob$ || (ChatMessageTokenLogprobTopLogprob$ = {}));
-export function chatMessageTokenLogprobTopLogprobToJSON(chatMessageTokenLogprobTopLogprob) {
-    return JSON.stringify(ChatMessageTokenLogprobTopLogprob$outboundSchema.parse(chatMessageTokenLogprobTopLogprob));
+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 chatMessageTokenLogprobTopLogprobFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ChatMessageTokenLogprobTopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatMessageTokenLogprobTopLogprob' from JSON`);
+export function topLogprobFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => TopLogprob$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'TopLogprob' from JSON`);
 }
 /** @internal */
 export const ChatMessageTokenLogprob$inboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
-    top_logprobs: z.array(z.lazy(() => ChatMessageTokenLogprobTopLogprob$inboundSchema)),
+    top_logprobs: z.array(z.lazy(() => TopLogprob$inboundSchema)),
 }).transform((v) => {
     return remap$(v, {
         "top_logprobs": "topLogprobs",
@@ -49,7 +50,7 @@ export const ChatMessageTokenLogprob$outboundSchema = z.object({
     token: z.string(),
     logprob: z.number(),
     bytes: z.nullable(z.array(z.number())),
-    topLogprobs: z.array(z.lazy(() => ChatMessageTokenLogprobTopLogprob$outboundSchema)),
+    topLogprobs: z.array(z.lazy(() => TopLogprob$outboundSchema)),
 }).transform((v) => {
     return remap$(v, {
         topLogprobs: "top_logprobs",

package/esm/models/chatstreamingresponsechunk.d.ts

@@ -7,7 +7,7 @@ export type ChatStreamingResponseChunkError = {
     message: string;
     code: number;
 };
-export type Data = {
+export type ChatStreamingResponseChunkData = {
     id: string;
     choices: Array<ChatStreamingChoice>;
     created: number;
@@ -18,7 +18,7 @@ export type Data = {
     usage?: ChatGenerationTokenUsage | undefined;
 };
 export type ChatStreamingResponseChunk = {
-    data: Data;
+    data: ChatStreamingResponseChunkData;
 };
 /** @internal */
 export declare const ChatStreamingResponseChunkError$inboundSchema: z.ZodType<ChatStreamingResponseChunkError, unknown>;
@@ -44,9 +44,9 @@ export declare namespace ChatStreamingResponseChunkError$ {
 export declare function chatStreamingResponseChunkErrorToJSON(chatStreamingResponseChunkError: ChatStreamingResponseChunkError): string;
 export declare function chatStreamingResponseChunkErrorFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkError, SDKValidationError>;
 /** @internal */
-export declare const Data$inboundSchema: z.ZodType<Data, unknown>;
+export declare const ChatStreamingResponseChunkData$inboundSchema: z.ZodType<ChatStreamingResponseChunkData, unknown>;
 /** @internal */
-export type Data$Outbound = {
+export type ChatStreamingResponseChunkData$Outbound = {
     id: string;
     choices: Array<ChatStreamingChoice$Outbound>;
     created: number;
@@ -57,26 +57,26 @@ export type Data$Outbound = {
     usage?: ChatGenerationTokenUsage$Outbound | undefined;
 };
 /** @internal */
-export declare const Data$outboundSchema: z.ZodType<Data$Outbound, Data>;
+export declare const ChatStreamingResponseChunkData$outboundSchema: z.ZodType<ChatStreamingResponseChunkData$Outbound, ChatStreamingResponseChunkData>;
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export declare namespace Data$ {
-    /** @deprecated use `Data$inboundSchema` instead. */
-    const inboundSchema: z.ZodType<Data, unknown, z.core.$ZodTypeInternals<Data, unknown>>;
-    /** @deprecated use `Data$outboundSchema` instead. */
-    const outboundSchema: z.ZodType<Data$Outbound, Data, z.core.$ZodTypeInternals<Data$Outbound, Data>>;
-    /** @deprecated use `Data$Outbound` instead. */
-    type Outbound = Data$Outbound;
+export declare namespace ChatStreamingResponseChunkData$ {
+    /** @deprecated use `ChatStreamingResponseChunkData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChatStreamingResponseChunkData, unknown, z.core.$ZodTypeInternals<ChatStreamingResponseChunkData, unknown>>;
+    /** @deprecated use `ChatStreamingResponseChunkData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChatStreamingResponseChunkData$Outbound, ChatStreamingResponseChunkData, z.core.$ZodTypeInternals<ChatStreamingResponseChunkData$Outbound, ChatStreamingResponseChunkData>>;
+    /** @deprecated use `ChatStreamingResponseChunkData$Outbound` instead. */
+    type Outbound = ChatStreamingResponseChunkData$Outbound;
 }
-export declare function dataToJSON(data: Data): string;
-export declare function dataFromJSON(jsonString: string): SafeParseResult<Data, SDKValidationError>;
+export declare function chatStreamingResponseChunkDataToJSON(chatStreamingResponseChunkData: ChatStreamingResponseChunkData): string;
+export declare function chatStreamingResponseChunkDataFromJSON(jsonString: string): SafeParseResult<ChatStreamingResponseChunkData, SDKValidationError>;
 /** @internal */
 export declare const ChatStreamingResponseChunk$inboundSchema: z.ZodType<ChatStreamingResponseChunk, unknown>;
 /** @internal */
 export type ChatStreamingResponseChunk$Outbound = {
-    data: Data$Outbound;
+    data: ChatStreamingResponseChunkData$Outbound;
 };
 /** @internal */
 export declare const ChatStreamingResponseChunk$outboundSchema: z.ZodType<ChatStreamingResponseChunk$Outbound, ChatStreamingResponseChunk>;

package/esm/models/chatstreamingresponsechunk.js

@@ -34,7 +34,7 @@ export function chatStreamingResponseChunkErrorFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ChatStreamingResponseChunkError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkError' from JSON`);
 }
 /** @internal */
-export const Data$inboundSchema = z.object({
+export const ChatStreamingResponseChunkData$inboundSchema = z.object({
     id: z.string(),
     choices: z.array(ChatStreamingChoice$inboundSchema),
     created: z.number(),
@@ -49,7 +49,7 @@ export const Data$inboundSchema = z.object({
     });
 });
 /** @internal */
-export const Data$outboundSchema = z.object({
+export const ChatStreamingResponseChunkData$outboundSchema = z.object({
     id: z.string(),
     choices: z.array(ChatStreamingChoice$outboundSchema),
     created: z.number(),
@@ -68,18 +68,18 @@ export const Data$outboundSchema = z.object({
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
  */
-export var Data$;
-(function (Data$) {
-    /** @deprecated use `Data$inboundSchema` instead. */
-    Data$.inboundSchema = Data$inboundSchema;
-    /** @deprecated use `Data$outboundSchema` instead. */
-    Data$.outboundSchema = Data$outboundSchema;
-})(Data$ || (Data$ = {}));
-export function dataToJSON(data) {
-    return JSON.stringify(Data$outboundSchema.parse(data));
+export var ChatStreamingResponseChunkData$;
+(function (ChatStreamingResponseChunkData$) {
+    /** @deprecated use `ChatStreamingResponseChunkData$inboundSchema` instead. */
+    ChatStreamingResponseChunkData$.inboundSchema = ChatStreamingResponseChunkData$inboundSchema;
+    /** @deprecated use `ChatStreamingResponseChunkData$outboundSchema` instead. */
+    ChatStreamingResponseChunkData$.outboundSchema = ChatStreamingResponseChunkData$outboundSchema;
+})(ChatStreamingResponseChunkData$ || (ChatStreamingResponseChunkData$ = {}));
+export function chatStreamingResponseChunkDataToJSON(chatStreamingResponseChunkData) {
+    return JSON.stringify(ChatStreamingResponseChunkData$outboundSchema.parse(chatStreamingResponseChunkData));
 }
-export function dataFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Data$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Data' from JSON`);
+export function chatStreamingResponseChunkDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatStreamingResponseChunkData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatStreamingResponseChunkData' from JSON`);
 }
 /** @internal */
 export const ChatStreamingResponseChunk$inboundSchema = z.object({
@@ -94,11 +94,11 @@ export const ChatStreamingResponseChunk$inboundSchema = z.object({
             });
             return z.NEVER;
         }
-    }).pipe(z.lazy(() => Data$inboundSchema)),
+    }).pipe(z.lazy(() => ChatStreamingResponseChunkData$inboundSchema)),
 });
 /** @internal */
 export const ChatStreamingResponseChunk$outboundSchema = z.object({
-    data: z.lazy(() => Data$outboundSchema),
+    data: z.lazy(() => ChatStreamingResponseChunkData$outboundSchema),
 });
 /**
  * @internal

package/esm/models/completioncreateparams.d.ts

@@ -33,7 +33,7 @@ export type CompletionCreateParams = {
     presencePenalty?: number | null | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
-    stream?: boolean | null | undefined;
+    stream?: boolean | undefined;
     streamOptions?: StreamOptions | null | undefined;
     suffix?: string | null | undefined;
     temperature?: number | null | undefined;
@@ -210,7 +210,7 @@ export type CompletionCreateParams$Outbound = {
     presence_penalty?: number | null | undefined;
     seed?: number | null | undefined;
     stop?: string | Array<string> | null | undefined;
-    stream?: boolean | null | undefined;
+    stream: boolean;
     stream_options?: StreamOptions$Outbound | null | undefined;
     suffix?: string | null | undefined;
     temperature?: number | null | undefined;

package/esm/models/completioncreateparams.js

@@ -220,7 +220,7 @@ export const CompletionCreateParams$inboundSchema = z.object({
     presence_penalty: z.nullable(z.number()).optional(),
     seed: z.nullable(z.number().int()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
-    stream: z.nullable(z.boolean()).optional(),
+    stream: z.boolean().default(false),
     stream_options: z.nullable(z.lazy(() => StreamOptions$inboundSchema))
         .optional(),
     suffix: z.nullable(z.string()).optional(),
@@ -266,7 +266,7 @@ export const CompletionCreateParams$outboundSchema = z.object({
     presencePenalty: z.nullable(z.number()).optional(),
     seed: z.nullable(z.number().int()).optional(),
     stop: z.nullable(z.union([z.string(), z.array(z.string())])).optional(),
-    stream: z.nullable(z.boolean()).optional(),
+    stream: z.boolean().default(false),
     streamOptions: z.nullable(z.lazy(() => StreamOptions$outboundSchema))
         .optional(),
     suffix: z.nullable(z.string()).optional(),

package/esm/models/createchargerequest.d.ts

@@ -1,14 +1,43 @@
 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";
+export declare const ChainId: {
+    readonly One: 1;
+    readonly OneHundredAndThirtySeven: 137;
+    readonly EightThousandFourHundredAndFiftyThree: 8453;
+};
+export type ChainId = OpenEnum<typeof ChainId>;
 /**
  * Create a Coinbase charge for crypto payment
  */
-export type CreateChargeRequest = {};
+export type CreateChargeRequest = {
+    amount: number;
+    sender: string;
+    chainId: ChainId;
+};
+/** @internal */
+export declare const ChainId$inboundSchema: z.ZodType<ChainId, unknown>;
+/** @internal */
+export declare const ChainId$outboundSchema: z.ZodType<ChainId, ChainId>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChainId$ {
+    /** @deprecated use `ChainId$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChainId, unknown, z.core.$ZodTypeInternals<ChainId, unknown>>;
+    /** @deprecated use `ChainId$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChainId, ChainId, z.core.$ZodTypeInternals<ChainId, ChainId>>;
+}
 /** @internal */
 export declare const CreateChargeRequest$inboundSchema: z.ZodType<CreateChargeRequest, unknown>;
 /** @internal */
-export type CreateChargeRequest$Outbound = {};
+export type CreateChargeRequest$Outbound = {
+    amount: number;
+    sender: string;
+    chain_id: number;
+};
 /** @internal */
 export declare const CreateChargeRequest$outboundSchema: z.ZodType<CreateChargeRequest$Outbound, CreateChargeRequest>;
 /**

package/esm/models/createchargerequest.js

@@ -2,11 +2,56 @@
  * 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";
+export const ChainId = {
+    One: 1,
+    OneHundredAndThirtySeven: 137,
+    EightThousandFourHundredAndFiftyThree: 8453,
+};
 /** @internal */
-export const CreateChargeRequest$inboundSchema = z.object({});
+export const ChainId$inboundSchema = z
+    .union([
+    z.enum(ChainId),
+    z.number().transform(catchUnrecognizedEnum),
+]);
 /** @internal */
-export const CreateChargeRequest$outboundSchema = z.object({});
+export const ChainId$outboundSchema = z.union([
+    z.enum(ChainId),
+    z.number().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 ChainId$;
+(function (ChainId$) {
+    /** @deprecated use `ChainId$inboundSchema` instead. */
+    ChainId$.inboundSchema = ChainId$inboundSchema;
+    /** @deprecated use `ChainId$outboundSchema` instead. */
+    ChainId$.outboundSchema = ChainId$outboundSchema;
+})(ChainId$ || (ChainId$ = {}));
+/** @internal */
+export const CreateChargeRequest$inboundSchema = z.object({
+    amount: z.number(),
+    sender: z.string(),
+    chain_id: ChainId$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "chain_id": "chainId",
+    });
+});
+/** @internal */
+export const CreateChargeRequest$outboundSchema = z.object({
+    amount: z.number(),
+    sender: z.string(),
+    chainId: ChainId$outboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        chainId: "chain_id",
+    });
+});
 /**
  * @internal
  * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.

package/esm/models/defaultparameters.d.ts

@@ -0,0 +1,36 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Default parameters for this model
+ */
+export type DefaultParameters = {
+    temperature?: number | null | undefined;
+    topP?: number | null | undefined;
+    frequencyPenalty?: number | null | undefined;
+};
+/** @internal */
+export declare const DefaultParameters$inboundSchema: z.ZodType<DefaultParameters, unknown>;
+/** @internal */
+export type DefaultParameters$Outbound = {
+    temperature?: number | null | undefined;
+    top_p?: number | null | undefined;
+    frequency_penalty?: number | null | undefined;
+};
+/** @internal */
+export declare const DefaultParameters$outboundSchema: z.ZodType<DefaultParameters$Outbound, DefaultParameters>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace DefaultParameters$ {
+    /** @deprecated use `DefaultParameters$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<DefaultParameters, unknown, z.core.$ZodTypeInternals<DefaultParameters, unknown>>;
+    /** @deprecated use `DefaultParameters$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<DefaultParameters$Outbound, DefaultParameters, z.core.$ZodTypeInternals<DefaultParameters$Outbound, DefaultParameters>>;
+    /** @deprecated use `DefaultParameters$Outbound` instead. */
+    type Outbound = DefaultParameters$Outbound;
+}
+export declare function defaultParametersToJSON(defaultParameters: DefaultParameters): string;
+export declare function defaultParametersFromJSON(jsonString: string): SafeParseResult<DefaultParameters, SDKValidationError>;
+//# sourceMappingURL=defaultparameters.d.ts.map

package/esm/models/defaultparameters.js

@@ -0,0 +1,46 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const DefaultParameters$inboundSchema = z.object({
+    temperature: z.nullable(z.number()).optional(),
+    top_p: z.nullable(z.number()).optional(),
+    frequency_penalty: z.nullable(z.number()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "top_p": "topP",
+        "frequency_penalty": "frequencyPenalty",
+    });
+});
+/** @internal */
+export const DefaultParameters$outboundSchema = z.object({
+    temperature: z.nullable(z.number()).optional(),
+    topP: z.nullable(z.number()).optional(),
+    frequencyPenalty: z.nullable(z.number()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        topP: "top_p",
+        frequencyPenalty: "frequency_penalty",
+    });
+});
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export var DefaultParameters$;
+(function (DefaultParameters$) {
+    /** @deprecated use `DefaultParameters$inboundSchema` instead. */
+    DefaultParameters$.inboundSchema = DefaultParameters$inboundSchema;
+    /** @deprecated use `DefaultParameters$outboundSchema` instead. */
+    DefaultParameters$.outboundSchema = DefaultParameters$outboundSchema;
+})(DefaultParameters$ || (DefaultParameters$ = {}));
+export function defaultParametersToJSON(defaultParameters) {
+    return JSON.stringify(DefaultParameters$outboundSchema.parse(defaultParameters));
+}
+export function defaultParametersFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DefaultParameters$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DefaultParameters' from JSON`);
+}
+//# sourceMappingURL=defaultparameters.js.map

package/esm/models/edgenetworktimeoutresponseerrordata.d.ts

@@ -0,0 +1,40 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * Error data for EdgeNetworkTimeoutResponse
+ */
+export type EdgeNetworkTimeoutResponseErrorData = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const EdgeNetworkTimeoutResponseErrorData$inboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData, unknown>;
+/** @internal */
+export type EdgeNetworkTimeoutResponseErrorData$Outbound = {
+    code: number;
+    message: string;
+    metadata?: {
+        [k: string]: any | null;
+    } | null | undefined;
+};
+/** @internal */
+export declare const EdgeNetworkTimeoutResponseErrorData$outboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData$Outbound, EdgeNetworkTimeoutResponseErrorData>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace EdgeNetworkTimeoutResponseErrorData$ {
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData, unknown, z.core.$ZodTypeInternals<EdgeNetworkTimeoutResponseErrorData, unknown>>;
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<EdgeNetworkTimeoutResponseErrorData$Outbound, EdgeNetworkTimeoutResponseErrorData, z.core.$ZodTypeInternals<EdgeNetworkTimeoutResponseErrorData$Outbound, EdgeNetworkTimeoutResponseErrorData>>;
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$Outbound` instead. */
+    type Outbound = EdgeNetworkTimeoutResponseErrorData$Outbound;
+}
+export declare function edgeNetworkTimeoutResponseErrorDataToJSON(edgeNetworkTimeoutResponseErrorData: EdgeNetworkTimeoutResponseErrorData): string;
+export declare function edgeNetworkTimeoutResponseErrorDataFromJSON(jsonString: string): SafeParseResult<EdgeNetworkTimeoutResponseErrorData, SDKValidationError>;
+//# sourceMappingURL=edgenetworktimeoutresponseerrordata.d.ts.map

package/esm/models/edgenetworktimeoutresponseerrordata.js

@@ -0,0 +1,35 @@
+/*
+ * 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 EdgeNetworkTimeoutResponseErrorData$inboundSchema = z.object({
+    code: z.number().int(),
+    message: z.string(),
+    metadata: z.nullable(z.record(z.string(), z.nullable(z.any()))).optional(),
+});
+/** @internal */
+export const EdgeNetworkTimeoutResponseErrorData$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 EdgeNetworkTimeoutResponseErrorData$;
+(function (EdgeNetworkTimeoutResponseErrorData$) {
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$inboundSchema` instead. */
+    EdgeNetworkTimeoutResponseErrorData$.inboundSchema = EdgeNetworkTimeoutResponseErrorData$inboundSchema;
+    /** @deprecated use `EdgeNetworkTimeoutResponseErrorData$outboundSchema` instead. */
+    EdgeNetworkTimeoutResponseErrorData$.outboundSchema = EdgeNetworkTimeoutResponseErrorData$outboundSchema;
+})(EdgeNetworkTimeoutResponseErrorData$ || (EdgeNetworkTimeoutResponseErrorData$ = {}));
+export function edgeNetworkTimeoutResponseErrorDataToJSON(edgeNetworkTimeoutResponseErrorData) {
+    return JSON.stringify(EdgeNetworkTimeoutResponseErrorData$outboundSchema.parse(edgeNetworkTimeoutResponseErrorData));
+}
+export function edgeNetworkTimeoutResponseErrorDataFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => EdgeNetworkTimeoutResponseErrorData$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'EdgeNetworkTimeoutResponseErrorData' from JSON`);
+}
+//# sourceMappingURL=edgenetworktimeoutresponseerrordata.js.map

package/esm/models/endpointstatus.d.ts

@@ -0,0 +1,26 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const EndpointStatus: {
+    readonly Zero: 0;
+    readonly Minus1: -1;
+    readonly Minus2: -2;
+    readonly Minus3: -3;
+    readonly Minus5: -5;
+    readonly Minus10: -10;
+};
+export type EndpointStatus = OpenEnum<typeof EndpointStatus>;
+/** @internal */
+export declare const EndpointStatus$inboundSchema: z.ZodType<EndpointStatus, unknown>;
+/** @internal */
+export declare const EndpointStatus$outboundSchema: z.ZodType<EndpointStatus, EndpointStatus>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace EndpointStatus$ {
+    /** @deprecated use `EndpointStatus$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<EndpointStatus, unknown, z.core.$ZodTypeInternals<EndpointStatus, unknown>>;
+    /** @deprecated use `EndpointStatus$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<EndpointStatus, EndpointStatus, z.core.$ZodTypeInternals<EndpointStatus, EndpointStatus>>;
+}
+//# sourceMappingURL=endpointstatus.d.ts.map

package/esm/models/endpointstatus.js

@@ -0,0 +1,36 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+import * as z from "zod/v4";
+import { catchUnrecognizedEnum, } from "../types/enums.js";
+export const EndpointStatus = {
+    Zero: 0,
+    Minus1: -1,
+    Minus2: -2,
+    Minus3: -3,
+    Minus5: -5,
+    Minus10: -10,
+};
+/** @internal */
+export const EndpointStatus$inboundSchema = z
+    .union([
+    z.enum(EndpointStatus),
+    z.number().transform(catchUnrecognizedEnum),
+]);
+/** @internal */
+export const EndpointStatus$outboundSchema = z.union([
+    z.enum(EndpointStatus),
+    z.number().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 EndpointStatus$;
+(function (EndpointStatus$) {
+    /** @deprecated use `EndpointStatus$inboundSchema` instead. */
+    EndpointStatus$.inboundSchema = EndpointStatus$inboundSchema;
+    /** @deprecated use `EndpointStatus$outboundSchema` instead. */
+    EndpointStatus$.outboundSchema = EndpointStatus$outboundSchema;
+})(EndpointStatus$ || (EndpointStatus$ = {}));
+//# sourceMappingURL=endpointstatus.js.map