@openrouter/sdk 0.13.44 → 0.13.46

package/esm/models/modelarchitecture.d.ts

@@ -1,41 +1,10 @@
 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 { 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
  */
@@ -47,7 +16,7 @@ export type ModelArchitecture = {
     /**
      * Instruction format type
      */
-    instructType?: ModelArchitectureInstructType | null | undefined;
+    instructType?: InstructType | null | undefined;
     /**
      * Primary modality of the model
      */
@@ -62,8 +31,6 @@ export type ModelArchitecture = {
     tokenizer?: ModelGroup | undefined;
 };
 /** @internal */
-export declare const ModelArchitectureInstructType$inboundSchema: z.ZodType<ModelArchitectureInstructType, unknown>;
-/** @internal */
 export declare const ModelArchitecture$inboundSchema: z.ZodType<ModelArchitecture, unknown>;
 export declare function modelArchitectureFromJSON(jsonString: string): SafeParseResult<ModelArchitecture, SDKValidationError>;
 //# sourceMappingURL=modelarchitecture.d.ts.map

package/esm/models/modelarchitecture.js

@@ -5,44 +5,14 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
 import { InputModality$inboundSchema } from "./inputmodality.js";
+import { InstructType$inboundSchema } from "./instructtype.js";
 import { ModelGroup$inboundSchema } from "./modelgroup.js";
 import { OutputModality$inboundSchema, } 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 = openEnums.inboundSchema(ModelArchitectureInstructType);
 /** @internal */
 export const ModelArchitecture$inboundSchema = z.object({
     input_modalities: z.array(InputModality$inboundSchema),
-    instruct_type: z.nullable(ModelArchitectureInstructType$inboundSchema)
-        .optional(),
+    instruct_type: z.nullable(InstructType$inboundSchema).optional(),
     modality: z.nullable(z.string()),
     output_modalities: z.array(OutputModality$inboundSchema),
     tokenizer: ModelGroup$inboundSchema.optional(),

package/esm/models/modelslistresponse.d.ts

@@ -2,6 +2,15 @@ import * as z from "zod/v4";
 import { Result as SafeParseResult } from "../types/fp.js";
 import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 import { Model } from "./model.js";
+/**
+ * Pagination links
+ */
+export type Links = {
+    /**
+     * URL for the next page of results, or null if this is the last page
+     */
+    next: string | null;
+};
 /**
  * List of available models
  */
@@ -10,8 +19,19 @@ export type ModelsListResponse = {
      * List of available models
      */
     data: Array<Model>;
+    /**
+     * Pagination links
+     */
+    links: Links;
+    /**
+     * Total number of models matching the query
+     */
+    totalCount: number;
 };
 /** @internal */
+export declare const Links$inboundSchema: z.ZodType<Links, unknown>;
+export declare function linksFromJSON(jsonString: string): SafeParseResult<Links, SDKValidationError>;
+/** @internal */
 export declare const ModelsListResponse$inboundSchema: z.ZodType<ModelsListResponse, unknown>;
 export declare function modelsListResponseFromJSON(jsonString: string): SafeParseResult<ModelsListResponse, SDKValidationError>;
 //# sourceMappingURL=modelslistresponse.d.ts.map

package/esm/models/modelslistresponse.js

@@ -3,11 +3,25 @@
  * @generated-id: ea0e62a13d8d
  */
 import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { Model$inboundSchema } from "./model.js";
 /** @internal */
+export const Links$inboundSchema = z.object({
+    next: z.nullable(z.string()),
+});
+export function linksFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Links$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Links' from JSON`);
+}
+/** @internal */
 export const ModelsListResponse$inboundSchema = z.object({
     data: z.array(Model$inboundSchema),
+    links: z.lazy(() => Links$inboundSchema),
+    total_count: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "total_count": "totalCount",
+    });
 });
 export function modelsListResponseFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ModelsListResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ModelsListResponse' from JSON`);

package/esm/models/observabilityfilterrulegroup.d.ts

@@ -0,0 +1,94 @@
+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 Logic: {
+    readonly And: "and";
+    readonly Or: "or";
+};
+export type Logic = OpenEnum<typeof Logic>;
+export declare const Field: {
+    readonly Model: "model";
+    readonly Provider: "provider";
+    readonly SessionId: "session_id";
+    readonly UserId: "user_id";
+    readonly ApiKeyName: "api_key_name";
+    readonly FinishReason: "finish_reason";
+    readonly Input: "input";
+    readonly Output: "output";
+    readonly TotalCost: "total_cost";
+    readonly TotalTokens: "total_tokens";
+    readonly PromptTokens: "prompt_tokens";
+    readonly CompletionTokens: "completion_tokens";
+};
+export type Field = OpenEnum<typeof Field>;
+export declare const Operator: {
+    readonly Equals: "equals";
+    readonly NotEquals: "not_equals";
+    readonly Contains: "contains";
+    readonly NotContains: "not_contains";
+    readonly Regex: "regex";
+    readonly StartsWith: "starts_with";
+    readonly EndsWith: "ends_with";
+    readonly Gt: "gt";
+    readonly Lt: "lt";
+    readonly Gte: "gte";
+    readonly Lte: "lte";
+    readonly Exists: "exists";
+    readonly NotExists: "not_exists";
+};
+export type Operator = OpenEnum<typeof Operator>;
+export type ObservabilityFilterRuleGroupValue = string | number;
+export type Rule = {
+    field: Field;
+    operator: Operator;
+    value?: string | number | undefined;
+};
+export type ObservabilityFilterRuleGroup = {
+    logic?: Logic | undefined;
+    rules: Array<Rule>;
+};
+/** @internal */
+export declare const Logic$inboundSchema: z.ZodType<Logic, unknown>;
+/** @internal */
+export declare const Logic$outboundSchema: z.ZodType<string, Logic>;
+/** @internal */
+export declare const Field$inboundSchema: z.ZodType<Field, unknown>;
+/** @internal */
+export declare const Field$outboundSchema: z.ZodType<string, Field>;
+/** @internal */
+export declare const Operator$inboundSchema: z.ZodType<Operator, unknown>;
+/** @internal */
+export declare const Operator$outboundSchema: z.ZodType<string, Operator>;
+/** @internal */
+export declare const ObservabilityFilterRuleGroupValue$inboundSchema: z.ZodType<ObservabilityFilterRuleGroupValue, unknown>;
+/** @internal */
+export type ObservabilityFilterRuleGroupValue$Outbound = string | number;
+/** @internal */
+export declare const ObservabilityFilterRuleGroupValue$outboundSchema: z.ZodType<ObservabilityFilterRuleGroupValue$Outbound, ObservabilityFilterRuleGroupValue>;
+export declare function observabilityFilterRuleGroupValueToJSON(observabilityFilterRuleGroupValue: ObservabilityFilterRuleGroupValue): string;
+export declare function observabilityFilterRuleGroupValueFromJSON(jsonString: string): SafeParseResult<ObservabilityFilterRuleGroupValue, SDKValidationError>;
+/** @internal */
+export declare const Rule$inboundSchema: z.ZodType<Rule, unknown>;
+/** @internal */
+export type Rule$Outbound = {
+    field: string;
+    operator: string;
+    value?: string | number | undefined;
+};
+/** @internal */
+export declare const Rule$outboundSchema: z.ZodType<Rule$Outbound, Rule>;
+export declare function ruleToJSON(rule: Rule): string;
+export declare function ruleFromJSON(jsonString: string): SafeParseResult<Rule, SDKValidationError>;
+/** @internal */
+export declare const ObservabilityFilterRuleGroup$inboundSchema: z.ZodType<ObservabilityFilterRuleGroup, unknown>;
+/** @internal */
+export type ObservabilityFilterRuleGroup$Outbound = {
+    logic: string;
+    rules: Array<Rule$Outbound>;
+};
+/** @internal */
+export declare const ObservabilityFilterRuleGroup$outboundSchema: z.ZodType<ObservabilityFilterRuleGroup$Outbound, ObservabilityFilterRuleGroup>;
+export declare function observabilityFilterRuleGroupToJSON(observabilityFilterRuleGroup: ObservabilityFilterRuleGroup): string;
+export declare function observabilityFilterRuleGroupFromJSON(jsonString: string): SafeParseResult<ObservabilityFilterRuleGroup, SDKValidationError>;
+//# sourceMappingURL=observabilityfilterrulegroup.d.ts.map

package/esm/models/observabilityfilterrulegroup.js

@@ -0,0 +1,103 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8d44f7499b39
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const Logic = {
+    And: "and",
+    Or: "or",
+};
+export const Field = {
+    Model: "model",
+    Provider: "provider",
+    SessionId: "session_id",
+    UserId: "user_id",
+    ApiKeyName: "api_key_name",
+    FinishReason: "finish_reason",
+    Input: "input",
+    Output: "output",
+    TotalCost: "total_cost",
+    TotalTokens: "total_tokens",
+    PromptTokens: "prompt_tokens",
+    CompletionTokens: "completion_tokens",
+};
+export const Operator = {
+    Equals: "equals",
+    NotEquals: "not_equals",
+    Contains: "contains",
+    NotContains: "not_contains",
+    Regex: "regex",
+    StartsWith: "starts_with",
+    EndsWith: "ends_with",
+    Gt: "gt",
+    Lt: "lt",
+    Gte: "gte",
+    Lte: "lte",
+    Exists: "exists",
+    NotExists: "not_exists",
+};
+/** @internal */
+export const Logic$inboundSchema = openEnums
+    .inboundSchema(Logic);
+/** @internal */
+export const Logic$outboundSchema = openEnums
+    .outboundSchema(Logic);
+/** @internal */
+export const Field$inboundSchema = openEnums
+    .inboundSchema(Field);
+/** @internal */
+export const Field$outboundSchema = openEnums
+    .outboundSchema(Field);
+/** @internal */
+export const Operator$inboundSchema = openEnums
+    .inboundSchema(Operator);
+/** @internal */
+export const Operator$outboundSchema = openEnums
+    .outboundSchema(Operator);
+/** @internal */
+export const ObservabilityFilterRuleGroupValue$inboundSchema = z.union([z.string(), z.number()]);
+/** @internal */
+export const ObservabilityFilterRuleGroupValue$outboundSchema = z.union([z.string(), z.number()]);
+export function observabilityFilterRuleGroupValueToJSON(observabilityFilterRuleGroupValue) {
+    return JSON.stringify(ObservabilityFilterRuleGroupValue$outboundSchema.parse(observabilityFilterRuleGroupValue));
+}
+export function observabilityFilterRuleGroupValueFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityFilterRuleGroupValue$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityFilterRuleGroupValue' from JSON`);
+}
+/** @internal */
+export const Rule$inboundSchema = z.object({
+    field: Field$inboundSchema,
+    operator: Operator$inboundSchema,
+    value: z.union([z.string(), z.number()]).optional(),
+});
+/** @internal */
+export const Rule$outboundSchema = z.object({
+    field: Field$outboundSchema,
+    operator: Operator$outboundSchema,
+    value: z.union([z.string(), z.number()]).optional(),
+});
+export function ruleToJSON(rule) {
+    return JSON.stringify(Rule$outboundSchema.parse(rule));
+}
+export function ruleFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Rule$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Rule' from JSON`);
+}
+/** @internal */
+export const ObservabilityFilterRuleGroup$inboundSchema = z.object({
+    logic: Logic$inboundSchema.default("and"),
+    rules: z.array(z.lazy(() => Rule$inboundSchema)),
+});
+/** @internal */
+export const ObservabilityFilterRuleGroup$outboundSchema = z.object({
+    logic: Logic$outboundSchema.default("and"),
+    rules: z.array(z.lazy(() => Rule$outboundSchema)),
+});
+export function observabilityFilterRuleGroupToJSON(observabilityFilterRuleGroup) {
+    return JSON.stringify(ObservabilityFilterRuleGroup$outboundSchema.parse(observabilityFilterRuleGroup));
+}
+export function observabilityFilterRuleGroupFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityFilterRuleGroup$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityFilterRuleGroup' from JSON`);
+}
+//# sourceMappingURL=observabilityfilterrulegroup.js.map

package/esm/models/observabilityfilterrulesconfig.d.ts

@@ -1,112 +1,15 @@
 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 Logic: {
-    readonly And: "and";
-    readonly Or: "or";
-};
-export type Logic = OpenEnum<typeof Logic>;
-export declare const Field: {
-    readonly Model: "model";
-    readonly Provider: "provider";
-    readonly SessionId: "session_id";
-    readonly UserId: "user_id";
-    readonly ApiKeyName: "api_key_name";
-    readonly FinishReason: "finish_reason";
-    readonly Input: "input";
-    readonly Output: "output";
-    readonly TotalCost: "total_cost";
-    readonly TotalTokens: "total_tokens";
-    readonly PromptTokens: "prompt_tokens";
-    readonly CompletionTokens: "completion_tokens";
-};
-export type Field = OpenEnum<typeof Field>;
-export declare const Operator: {
-    readonly Equals: "equals";
-    readonly NotEquals: "not_equals";
-    readonly Contains: "contains";
-    readonly NotContains: "not_contains";
-    readonly Regex: "regex";
-    readonly StartsWith: "starts_with";
-    readonly EndsWith: "ends_with";
-    readonly Gt: "gt";
-    readonly Lt: "lt";
-    readonly Gte: "gte";
-    readonly Lte: "lte";
-    readonly Exists: "exists";
-    readonly NotExists: "not_exists";
-};
-export type Operator = OpenEnum<typeof Operator>;
-export type ObservabilityFilterRulesConfigValue = string | number;
-export type Rule = {
-    field: Field;
-    operator: Operator;
-    value?: string | number | undefined;
-};
-export type Group = {
-    logic?: Logic | undefined;
-    rules: Array<Rule>;
-};
+import { ObservabilityFilterRuleGroup } from "./observabilityfilterrulegroup.js";
 /**
  * Optional structured filter rules controlling which events are forwarded.
  */
 export type ObservabilityFilterRulesConfig = {
-    enabled?: boolean | undefined;
-    groups: Array<Group>;
-};
-/** @internal */
-export declare const Logic$inboundSchema: z.ZodType<Logic, unknown>;
-/** @internal */
-export declare const Logic$outboundSchema: z.ZodType<string, Logic>;
-/** @internal */
-export declare const Field$inboundSchema: z.ZodType<Field, unknown>;
-/** @internal */
-export declare const Field$outboundSchema: z.ZodType<string, Field>;
-/** @internal */
-export declare const Operator$inboundSchema: z.ZodType<Operator, unknown>;
-/** @internal */
-export declare const Operator$outboundSchema: z.ZodType<string, Operator>;
-/** @internal */
-export declare const ObservabilityFilterRulesConfigValue$inboundSchema: z.ZodType<ObservabilityFilterRulesConfigValue, unknown>;
-/** @internal */
-export type ObservabilityFilterRulesConfigValue$Outbound = string | number;
-/** @internal */
-export declare const ObservabilityFilterRulesConfigValue$outboundSchema: z.ZodType<ObservabilityFilterRulesConfigValue$Outbound, ObservabilityFilterRulesConfigValue>;
-export declare function observabilityFilterRulesConfigValueToJSON(observabilityFilterRulesConfigValue: ObservabilityFilterRulesConfigValue): string;
-export declare function observabilityFilterRulesConfigValueFromJSON(jsonString: string): SafeParseResult<ObservabilityFilterRulesConfigValue, SDKValidationError>;
-/** @internal */
-export declare const Rule$inboundSchema: z.ZodType<Rule, unknown>;
-/** @internal */
-export type Rule$Outbound = {
-    field: string;
-    operator: string;
-    value?: string | number | undefined;
-};
-/** @internal */
-export declare const Rule$outboundSchema: z.ZodType<Rule$Outbound, Rule>;
-export declare function ruleToJSON(rule: Rule): string;
-export declare function ruleFromJSON(jsonString: string): SafeParseResult<Rule, SDKValidationError>;
-/** @internal */
-export declare const Group$inboundSchema: z.ZodType<Group, unknown>;
-/** @internal */
-export type Group$Outbound = {
-    logic: string;
-    rules: Array<Rule$Outbound>;
-};
-/** @internal */
-export declare const Group$outboundSchema: z.ZodType<Group$Outbound, Group>;
-export declare function groupToJSON(group: Group): string;
-export declare function groupFromJSON(jsonString: string): SafeParseResult<Group, SDKValidationError>;
-/** @internal */
-export declare const ObservabilityFilterRulesConfig$inboundSchema: z.ZodType<ObservabilityFilterRulesConfig, unknown>;
-/** @internal */
-export type ObservabilityFilterRulesConfig$Outbound = {
     enabled: boolean;
-    groups: Array<Group$Outbound>;
+    groups: Array<ObservabilityFilterRuleGroup>;
 };
 /** @internal */
-export declare const ObservabilityFilterRulesConfig$outboundSchema: z.ZodType<ObservabilityFilterRulesConfig$Outbound, ObservabilityFilterRulesConfig>;
-export declare function observabilityFilterRulesConfigToJSON(observabilityFilterRulesConfig: ObservabilityFilterRulesConfig): string;
+export declare const ObservabilityFilterRulesConfig$inboundSchema: z.ZodType<ObservabilityFilterRulesConfig, unknown>;
 export declare function observabilityFilterRulesConfigFromJSON(jsonString: string): SafeParseResult<ObservabilityFilterRulesConfig, SDKValidationError>;
 //# sourceMappingURL=observabilityfilterrulesconfig.d.ts.map

package/esm/models/observabilityfilterrulesconfig.js

@@ -4,115 +4,12 @@
  */
 import * as z from "zod/v4";
 import { safeParse } from "../lib/schemas.js";
-import * as openEnums from "../types/enums.js";
-export const Logic = {
-    And: "and",
-    Or: "or",
-};
-export const Field = {
-    Model: "model",
-    Provider: "provider",
-    SessionId: "session_id",
-    UserId: "user_id",
-    ApiKeyName: "api_key_name",
-    FinishReason: "finish_reason",
-    Input: "input",
-    Output: "output",
-    TotalCost: "total_cost",
-    TotalTokens: "total_tokens",
-    PromptTokens: "prompt_tokens",
-    CompletionTokens: "completion_tokens",
-};
-export const Operator = {
-    Equals: "equals",
-    NotEquals: "not_equals",
-    Contains: "contains",
-    NotContains: "not_contains",
-    Regex: "regex",
-    StartsWith: "starts_with",
-    EndsWith: "ends_with",
-    Gt: "gt",
-    Lt: "lt",
-    Gte: "gte",
-    Lte: "lte",
-    Exists: "exists",
-    NotExists: "not_exists",
-};
-/** @internal */
-export const Logic$inboundSchema = openEnums
-    .inboundSchema(Logic);
-/** @internal */
-export const Logic$outboundSchema = openEnums
-    .outboundSchema(Logic);
-/** @internal */
-export const Field$inboundSchema = openEnums
-    .inboundSchema(Field);
-/** @internal */
-export const Field$outboundSchema = openEnums
-    .outboundSchema(Field);
-/** @internal */
-export const Operator$inboundSchema = openEnums
-    .inboundSchema(Operator);
-/** @internal */
-export const Operator$outboundSchema = openEnums
-    .outboundSchema(Operator);
-/** @internal */
-export const ObservabilityFilterRulesConfigValue$inboundSchema = z.union([z.string(), z.number()]);
-/** @internal */
-export const ObservabilityFilterRulesConfigValue$outboundSchema = z.union([z.string(), z.number()]);
-export function observabilityFilterRulesConfigValueToJSON(observabilityFilterRulesConfigValue) {
-    return JSON.stringify(ObservabilityFilterRulesConfigValue$outboundSchema.parse(observabilityFilterRulesConfigValue));
-}
-export function observabilityFilterRulesConfigValueFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => ObservabilityFilterRulesConfigValue$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityFilterRulesConfigValue' from JSON`);
-}
-/** @internal */
-export const Rule$inboundSchema = z.object({
-    field: Field$inboundSchema,
-    operator: Operator$inboundSchema,
-    value: z.union([z.string(), z.number()]).optional(),
-});
-/** @internal */
-export const Rule$outboundSchema = z.object({
-    field: Field$outboundSchema,
-    operator: Operator$outboundSchema,
-    value: z.union([z.string(), z.number()]).optional(),
-});
-export function ruleToJSON(rule) {
-    return JSON.stringify(Rule$outboundSchema.parse(rule));
-}
-export function ruleFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Rule$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Rule' from JSON`);
-}
-/** @internal */
-export const Group$inboundSchema = z.object({
-    logic: Logic$inboundSchema.default("and"),
-    rules: z.array(z.lazy(() => Rule$inboundSchema)),
-});
-/** @internal */
-export const Group$outboundSchema = z.object({
-    logic: Logic$outboundSchema.default("and"),
-    rules: z.array(z.lazy(() => Rule$outboundSchema)),
-});
-export function groupToJSON(group) {
-    return JSON.stringify(Group$outboundSchema.parse(group));
-}
-export function groupFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => Group$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Group' from JSON`);
-}
+import { ObservabilityFilterRuleGroup$inboundSchema, } from "./observabilityfilterrulegroup.js";
 /** @internal */
 export const ObservabilityFilterRulesConfig$inboundSchema = z.object({
     enabled: z.boolean().default(true),
-    groups: z.array(z.lazy(() => Group$inboundSchema)),
-});
-/** @internal */
-export const ObservabilityFilterRulesConfig$outboundSchema = z.object({
-    enabled: z.boolean().default(true),
-    groups: z.array(z.lazy(() => Group$outboundSchema)),
+    groups: z.array(ObservabilityFilterRuleGroup$inboundSchema),
 });
-export function observabilityFilterRulesConfigToJSON(observabilityFilterRulesConfig) {
-    return JSON.stringify(ObservabilityFilterRulesConfig$outboundSchema.parse(observabilityFilterRulesConfig));
-}
 export function observabilityFilterRulesConfigFromJSON(jsonString) {
     return safeParse(jsonString, (x) => ObservabilityFilterRulesConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityFilterRulesConfig' from JSON`);
 }

package/esm/models/observabilityfilterrulesconfignullable.d.ts

@@ -0,0 +1,18 @@
+import * as z from "zod/v4";
+import { ObservabilityFilterRuleGroup, ObservabilityFilterRuleGroup$Outbound } from "./observabilityfilterrulegroup.js";
+/**
+ * Optional structured filter rules controlling which events are forwarded.
+ */
+export type ObservabilityFilterRulesConfigNullable = {
+    enabled?: boolean | undefined;
+    groups: Array<ObservabilityFilterRuleGroup>;
+};
+/** @internal */
+export type ObservabilityFilterRulesConfigNullable$Outbound = {
+    enabled: boolean;
+    groups: Array<ObservabilityFilterRuleGroup$Outbound>;
+};
+/** @internal */
+export declare const ObservabilityFilterRulesConfigNullable$outboundSchema: z.ZodType<ObservabilityFilterRulesConfigNullable$Outbound, ObservabilityFilterRulesConfigNullable>;
+export declare function observabilityFilterRulesConfigNullableToJSON(observabilityFilterRulesConfigNullable: ObservabilityFilterRulesConfigNullable): string;
+//# sourceMappingURL=observabilityfilterrulesconfignullable.d.ts.map

package/esm/models/observabilityfilterrulesconfignullable.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e9a4ec0d425c
+ */
+import * as z from "zod/v4";
+import { ObservabilityFilterRuleGroup$outboundSchema, } from "./observabilityfilterrulegroup.js";
+/** @internal */
+export const ObservabilityFilterRulesConfigNullable$outboundSchema = z.object({
+    enabled: z.boolean().default(true),
+    groups: z.array(ObservabilityFilterRuleGroup$outboundSchema),
+});
+export function observabilityFilterRulesConfigNullableToJSON(observabilityFilterRulesConfigNullable) {
+    return JSON.stringify(ObservabilityFilterRulesConfigNullable$outboundSchema.parse(observabilityFilterRulesConfigNullable));
+}
+//# sourceMappingURL=observabilityfilterrulesconfignullable.js.map

package/esm/models/operations/createembeddings.d.ts

@@ -132,14 +132,6 @@ export declare const ObjectT: {
     readonly List: "list";
 };
 export type ObjectT = ClosedEnum<typeof ObjectT>;
-/**
- * Breakdown of upstream inference costs
- */
-export type CostDetails = {
-    upstreamInferenceCompletionsCost: number;
-    upstreamInferenceCost?: number | null | undefined;
-    upstreamInferencePromptCost: number;
-};
 /**
  * Per-modality token breakdown. Only present when the input contains 2+ modalities (e.g. text + image) and the upstream provider returns modality-level usage data. Only non-zero modality counts are included.
  */
@@ -176,7 +168,7 @@ export type CreateEmbeddingsUsage = {
     /**
      * Breakdown of upstream inference costs
      */
-    costDetails?: CostDetails | null | undefined;
+    costDetails?: models.CostDetails | null | undefined;
     /**
      * Whether a request was made using a Bring Your Own Key configuration
      */
@@ -293,9 +285,6 @@ export declare function createEmbeddingsDataFromJSON(jsonString: string): SafePa
 /** @internal */
 export declare const ObjectT$inboundSchema: z.ZodEnum<typeof ObjectT>;
 /** @internal */
-export declare const CostDetails$inboundSchema: z.ZodType<CostDetails, unknown>;
-export declare function costDetailsFromJSON(jsonString: string): SafeParseResult<CostDetails, SDKValidationError>;
-/** @internal */
 export declare const PromptTokensDetails$inboundSchema: z.ZodType<PromptTokensDetails, unknown>;
 export declare function promptTokensDetailsFromJSON(jsonString: string): SafeParseResult<PromptTokensDetails, SDKValidationError>;
 /** @internal */