@openrouter/sdk 0.12.35 → 0.13.7

package/esm/models/observabilityfilterrulesconfig.d.ts

@@ -0,0 +1,112 @@
+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>;
+};
+/**
+ * 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>;
+};
+/** @internal */
+export declare const ObservabilityFilterRulesConfig$outboundSchema: z.ZodType<ObservabilityFilterRulesConfig$Outbound, ObservabilityFilterRulesConfig>;
+export declare function observabilityFilterRulesConfigToJSON(observabilityFilterRulesConfig: ObservabilityFilterRulesConfig): string;
+export declare function observabilityFilterRulesConfigFromJSON(jsonString: string): SafeParseResult<ObservabilityFilterRulesConfig, SDKValidationError>;
+//# sourceMappingURL=observabilityfilterrulesconfig.d.ts.map

package/esm/models/observabilityfilterrulesconfig.js

@@ -0,0 +1,119 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 297eacee53a2
+ */
+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`);
+}
+/** @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)),
+});
+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`);
+}
+//# sourceMappingURL=observabilityfilterrulesconfig.js.map

package/esm/models/observabilitygrafanadestination.d.ts

@@ -0,0 +1,66 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ObservabilityFilterRulesConfig } from "./observabilityfilterrulesconfig.js";
+export type ObservabilityGrafanaDestinationConfig = {
+    apiKey: string;
+    baseUrl: string;
+    /**
+     * Custom HTTP headers to include in requests to this destination.
+     */
+    headers?: {
+        [k: string]: string;
+    } | undefined;
+    instanceId: string;
+};
+export type ObservabilityGrafanaDestination = {
+    /**
+     * Optional allowlist of OpenRouter API key hashes (`api_keys.hash`) whose traffic is forwarded to this destination. `null` means all keys.
+     */
+    apiKeyHashes: Array<string> | null;
+    config: ObservabilityGrafanaDestinationConfig;
+    /**
+     * ISO timestamp of when the destination was created.
+     */
+    createdAt: string;
+    /**
+     * Whether this destination is currently enabled.
+     */
+    enabled: boolean;
+    /**
+     * Optional structured filter rules controlling which events are forwarded.
+     */
+    filterRules: ObservabilityFilterRulesConfig | null;
+    /**
+     * Stable public identifier for this destination.
+     */
+    id: string;
+    /**
+     * Human-readable name for the destination.
+     */
+    name: string | null;
+    /**
+     * When true, request/response bodies are not forwarded to this destination — only metadata.
+     */
+    privacyMode: boolean;
+    /**
+     * Sampling rate for events sent to this destination, between 0.0001 and 1 (1 = 100%).
+     */
+    samplingRate: number;
+    type: "grafana";
+    /**
+     * ISO timestamp of when the destination was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ID of the workspace this destination belongs to.
+     */
+    workspaceId: string;
+};
+/** @internal */
+export declare const ObservabilityGrafanaDestinationConfig$inboundSchema: z.ZodType<ObservabilityGrafanaDestinationConfig, unknown>;
+export declare function observabilityGrafanaDestinationConfigFromJSON(jsonString: string): SafeParseResult<ObservabilityGrafanaDestinationConfig, SDKValidationError>;
+/** @internal */
+export declare const ObservabilityGrafanaDestination$inboundSchema: z.ZodType<ObservabilityGrafanaDestination, unknown>;
+export declare function observabilityGrafanaDestinationFromJSON(jsonString: string): SafeParseResult<ObservabilityGrafanaDestination, SDKValidationError>;
+//# sourceMappingURL=observabilitygrafanadestination.d.ts.map

package/esm/models/observabilitygrafanadestination.js

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 26c17318c1d5
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ObservabilityFilterRulesConfig$inboundSchema, } from "./observabilityfilterrulesconfig.js";
+/** @internal */
+export const ObservabilityGrafanaDestinationConfig$inboundSchema = z.object({
+    apiKey: z.string(),
+    baseUrl: z.string().default("https://otlp-gateway-prod-us-west-0.grafana.net"),
+    headers: z.record(z.string(), z.string()).optional(),
+    instanceId: z.string(),
+});
+export function observabilityGrafanaDestinationConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityGrafanaDestinationConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityGrafanaDestinationConfig' from JSON`);
+}
+/** @internal */
+export const ObservabilityGrafanaDestination$inboundSchema = z.object({
+    api_key_hashes: z.nullable(z.array(z.string())),
+    config: z.lazy(() => ObservabilityGrafanaDestinationConfig$inboundSchema),
+    created_at: z.string(),
+    enabled: z.boolean(),
+    filter_rules: z.nullable(ObservabilityFilterRulesConfig$inboundSchema),
+    id: z.string(),
+    name: z.nullable(z.string()),
+    privacy_mode: z.boolean(),
+    sampling_rate: z.number(),
+    type: z.literal("grafana"),
+    updated_at: z.string(),
+    workspace_id: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "api_key_hashes": "apiKeyHashes",
+        "created_at": "createdAt",
+        "filter_rules": "filterRules",
+        "privacy_mode": "privacyMode",
+        "sampling_rate": "samplingRate",
+        "updated_at": "updatedAt",
+        "workspace_id": "workspaceId",
+    });
+});
+export function observabilityGrafanaDestinationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityGrafanaDestination$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityGrafanaDestination' from JSON`);
+}
+//# sourceMappingURL=observabilitygrafanadestination.js.map

package/esm/models/observabilitylangfusedestination.d.ts

@@ -0,0 +1,66 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ObservabilityFilterRulesConfig } from "./observabilityfilterrulesconfig.js";
+export type ObservabilityLangfuseDestinationConfig = {
+    baseUrl: string;
+    /**
+     * Custom HTTP headers to include in requests to this destination.
+     */
+    headers?: {
+        [k: string]: string;
+    } | undefined;
+    publicKey: string;
+    secretKey: string;
+};
+export type ObservabilityLangfuseDestination = {
+    /**
+     * Optional allowlist of OpenRouter API key hashes (`api_keys.hash`) whose traffic is forwarded to this destination. `null` means all keys.
+     */
+    apiKeyHashes: Array<string> | null;
+    config: ObservabilityLangfuseDestinationConfig;
+    /**
+     * ISO timestamp of when the destination was created.
+     */
+    createdAt: string;
+    /**
+     * Whether this destination is currently enabled.
+     */
+    enabled: boolean;
+    /**
+     * Optional structured filter rules controlling which events are forwarded.
+     */
+    filterRules: ObservabilityFilterRulesConfig | null;
+    /**
+     * Stable public identifier for this destination.
+     */
+    id: string;
+    /**
+     * Human-readable name for the destination.
+     */
+    name: string | null;
+    /**
+     * When true, request/response bodies are not forwarded to this destination — only metadata.
+     */
+    privacyMode: boolean;
+    /**
+     * Sampling rate for events sent to this destination, between 0.0001 and 1 (1 = 100%).
+     */
+    samplingRate: number;
+    type: "langfuse";
+    /**
+     * ISO timestamp of when the destination was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ID of the workspace this destination belongs to.
+     */
+    workspaceId: string;
+};
+/** @internal */
+export declare const ObservabilityLangfuseDestinationConfig$inboundSchema: z.ZodType<ObservabilityLangfuseDestinationConfig, unknown>;
+export declare function observabilityLangfuseDestinationConfigFromJSON(jsonString: string): SafeParseResult<ObservabilityLangfuseDestinationConfig, SDKValidationError>;
+/** @internal */
+export declare const ObservabilityLangfuseDestination$inboundSchema: z.ZodType<ObservabilityLangfuseDestination, unknown>;
+export declare function observabilityLangfuseDestinationFromJSON(jsonString: string): SafeParseResult<ObservabilityLangfuseDestination, SDKValidationError>;
+//# sourceMappingURL=observabilitylangfusedestination.d.ts.map

package/esm/models/observabilitylangfusedestination.js

@@ -0,0 +1,47 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 866372fcdbce
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ObservabilityFilterRulesConfig$inboundSchema, } from "./observabilityfilterrulesconfig.js";
+/** @internal */
+export const ObservabilityLangfuseDestinationConfig$inboundSchema = z.object({
+    baseUrl: z.string().default("https://us.cloud.langfuse.com"),
+    headers: z.record(z.string(), z.string()).optional(),
+    publicKey: z.string(),
+    secretKey: z.string(),
+});
+export function observabilityLangfuseDestinationConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityLangfuseDestinationConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityLangfuseDestinationConfig' from JSON`);
+}
+/** @internal */
+export const ObservabilityLangfuseDestination$inboundSchema = z.object({
+    api_key_hashes: z.nullable(z.array(z.string())),
+    config: z.lazy(() => ObservabilityLangfuseDestinationConfig$inboundSchema),
+    created_at: z.string(),
+    enabled: z.boolean(),
+    filter_rules: z.nullable(ObservabilityFilterRulesConfig$inboundSchema),
+    id: z.string(),
+    name: z.nullable(z.string()),
+    privacy_mode: z.boolean(),
+    sampling_rate: z.number(),
+    type: z.literal("langfuse"),
+    updated_at: z.string(),
+    workspace_id: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "api_key_hashes": "apiKeyHashes",
+        "created_at": "createdAt",
+        "filter_rules": "filterRules",
+        "privacy_mode": "privacyMode",
+        "sampling_rate": "samplingRate",
+        "updated_at": "updatedAt",
+        "workspace_id": "workspaceId",
+    });
+});
+export function observabilityLangfuseDestinationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityLangfuseDestination$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityLangfuseDestination' from JSON`);
+}
+//# sourceMappingURL=observabilitylangfusedestination.js.map

package/esm/models/observabilitylangsmithdestination.d.ts

@@ -0,0 +1,73 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ObservabilityFilterRulesConfig } from "./observabilityfilterrulesconfig.js";
+export type ObservabilityLangsmithDestinationConfig = {
+    apiKey: string;
+    endpoint: string;
+    /**
+     * Custom HTTP headers to include in requests to this destination.
+     */
+    headers?: {
+        [k: string]: string;
+    } | undefined;
+    /**
+     * The name for this project, such as pr-openrouter-demo. Defaults to "main" if not set.
+     */
+    project: string;
+    /**
+     * Required for org-scoped API keys. Find this in your LangSmith workspace settings.
+     */
+    workspaceId?: string | undefined;
+};
+export type ObservabilityLangsmithDestination = {
+    /**
+     * Optional allowlist of OpenRouter API key hashes (`api_keys.hash`) whose traffic is forwarded to this destination. `null` means all keys.
+     */
+    apiKeyHashes: Array<string> | null;
+    config: ObservabilityLangsmithDestinationConfig;
+    /**
+     * ISO timestamp of when the destination was created.
+     */
+    createdAt: string;
+    /**
+     * Whether this destination is currently enabled.
+     */
+    enabled: boolean;
+    /**
+     * Optional structured filter rules controlling which events are forwarded.
+     */
+    filterRules: ObservabilityFilterRulesConfig | null;
+    /**
+     * Stable public identifier for this destination.
+     */
+    id: string;
+    /**
+     * Human-readable name for the destination.
+     */
+    name: string | null;
+    /**
+     * When true, request/response bodies are not forwarded to this destination — only metadata.
+     */
+    privacyMode: boolean;
+    /**
+     * Sampling rate for events sent to this destination, between 0.0001 and 1 (1 = 100%).
+     */
+    samplingRate: number;
+    type: "langsmith";
+    /**
+     * ISO timestamp of when the destination was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ID of the workspace this destination belongs to.
+     */
+    workspaceId: string;
+};
+/** @internal */
+export declare const ObservabilityLangsmithDestinationConfig$inboundSchema: z.ZodType<ObservabilityLangsmithDestinationConfig, unknown>;
+export declare function observabilityLangsmithDestinationConfigFromJSON(jsonString: string): SafeParseResult<ObservabilityLangsmithDestinationConfig, SDKValidationError>;
+/** @internal */
+export declare const ObservabilityLangsmithDestination$inboundSchema: z.ZodType<ObservabilityLangsmithDestination, unknown>;
+export declare function observabilityLangsmithDestinationFromJSON(jsonString: string): SafeParseResult<ObservabilityLangsmithDestination, SDKValidationError>;
+//# sourceMappingURL=observabilitylangsmithdestination.d.ts.map

package/esm/models/observabilitylangsmithdestination.js

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ed70d9202997
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ObservabilityFilterRulesConfig$inboundSchema, } from "./observabilityfilterrulesconfig.js";
+/** @internal */
+export const ObservabilityLangsmithDestinationConfig$inboundSchema = z.object({
+    apiKey: z.string(),
+    endpoint: z.string().default("https://api.smith.langchain.com"),
+    headers: z.record(z.string(), z.string()).optional(),
+    project: z.string().default("main"),
+    workspaceId: z.string().optional(),
+});
+export function observabilityLangsmithDestinationConfigFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityLangsmithDestinationConfig$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityLangsmithDestinationConfig' from JSON`);
+}
+/** @internal */
+export const ObservabilityLangsmithDestination$inboundSchema = z.object({
+    api_key_hashes: z.nullable(z.array(z.string())),
+    config: z.lazy(() => ObservabilityLangsmithDestinationConfig$inboundSchema),
+    created_at: z.string(),
+    enabled: z.boolean(),
+    filter_rules: z.nullable(ObservabilityFilterRulesConfig$inboundSchema),
+    id: z.string(),
+    name: z.nullable(z.string()),
+    privacy_mode: z.boolean(),
+    sampling_rate: z.number(),
+    type: z.literal("langsmith"),
+    updated_at: z.string(),
+    workspace_id: z.string(),
+}).transform((v) => {
+    return remap$(v, {
+        "api_key_hashes": "apiKeyHashes",
+        "created_at": "createdAt",
+        "filter_rules": "filterRules",
+        "privacy_mode": "privacyMode",
+        "sampling_rate": "samplingRate",
+        "updated_at": "updatedAt",
+        "workspace_id": "workspaceId",
+    });
+});
+export function observabilityLangsmithDestinationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ObservabilityLangsmithDestination$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ObservabilityLangsmithDestination' from JSON`);
+}
+//# sourceMappingURL=observabilitylangsmithdestination.js.map

package/esm/models/observabilitynewrelicdestination.d.ts

@@ -0,0 +1,73 @@
+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 { ObservabilityFilterRulesConfig } from "./observabilityfilterrulesconfig.js";
+export declare const Region: {
+    readonly Us: "us";
+    readonly Eu: "eu";
+};
+export type Region = OpenEnum<typeof Region>;
+export type ObservabilityNewrelicDestinationConfig = {
+    /**
+     * Custom HTTP headers to include in requests to this destination.
+     */
+    headers?: {
+        [k: string]: string;
+    } | undefined;
+    licenseKey: string;
+    region: Region;
+};
+export type ObservabilityNewrelicDestination = {
+    /**
+     * Optional allowlist of OpenRouter API key hashes (`api_keys.hash`) whose traffic is forwarded to this destination. `null` means all keys.
+     */
+    apiKeyHashes: Array<string> | null;
+    config: ObservabilityNewrelicDestinationConfig;
+    /**
+     * ISO timestamp of when the destination was created.
+     */
+    createdAt: string;
+    /**
+     * Whether this destination is currently enabled.
+     */
+    enabled: boolean;
+    /**
+     * Optional structured filter rules controlling which events are forwarded.
+     */
+    filterRules: ObservabilityFilterRulesConfig | null;
+    /**
+     * Stable public identifier for this destination.
+     */
+    id: string;
+    /**
+     * Human-readable name for the destination.
+     */
+    name: string | null;
+    /**
+     * When true, request/response bodies are not forwarded to this destination — only metadata.
+     */
+    privacyMode: boolean;
+    /**
+     * Sampling rate for events sent to this destination, between 0.0001 and 1 (1 = 100%).
+     */
+    samplingRate: number;
+    type: "newrelic";
+    /**
+     * ISO timestamp of when the destination was last updated.
+     */
+    updatedAt: string;
+    /**
+     * ID of the workspace this destination belongs to.
+     */
+    workspaceId: string;
+};
+/** @internal */
+export declare const Region$inboundSchema: z.ZodType<Region, unknown>;
+/** @internal */
+export declare const ObservabilityNewrelicDestinationConfig$inboundSchema: z.ZodType<ObservabilityNewrelicDestinationConfig, unknown>;
+export declare function observabilityNewrelicDestinationConfigFromJSON(jsonString: string): SafeParseResult<ObservabilityNewrelicDestinationConfig, SDKValidationError>;
+/** @internal */
+export declare const ObservabilityNewrelicDestination$inboundSchema: z.ZodType<ObservabilityNewrelicDestination, unknown>;
+export declare function observabilityNewrelicDestinationFromJSON(jsonString: string): SafeParseResult<ObservabilityNewrelicDestination, SDKValidationError>;
+//# sourceMappingURL=observabilitynewrelicdestination.d.ts.map