@openrouter/sdk 1.3.29 → 1.3.30

package/esm/models/anthropicoutputtokensdetails.js

@@ -0,0 +1,19 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 1c1cbd5cc017
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicOutputTokensDetails$inboundSchema = z.object({
+    thinking_tokens: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "thinking_tokens": "thinkingTokens",
+    });
+});
+export function anthropicOutputTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicOutputTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicOutputTokensDetails' from JSON`);
+}
+//# sourceMappingURL=anthropicoutputtokensdetails.js.map

package/esm/models/anthropicplaintextsource.d.ts

@@ -1,23 +1,38 @@
 import * as z from "zod/v4";
 import { ClosedEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
 export declare const AnthropicPlainTextSourceMediaType: {
     readonly TextPlain: "text/plain";
 };
 export type AnthropicPlainTextSourceMediaType = ClosedEnum<typeof AnthropicPlainTextSourceMediaType>;
+export declare const AnthropicPlainTextSourceType: {
+    readonly Text: "text";
+};
+export type AnthropicPlainTextSourceType = ClosedEnum<typeof AnthropicPlainTextSourceType>;
 export type AnthropicPlainTextSource = {
     data: string;
     mediaType: AnthropicPlainTextSourceMediaType;
-    type: "text";
+    type: AnthropicPlainTextSourceType;
 };
 /** @internal */
+export declare const AnthropicPlainTextSourceMediaType$inboundSchema: z.ZodEnum<typeof AnthropicPlainTextSourceMediaType>;
+/** @internal */
 export declare const AnthropicPlainTextSourceMediaType$outboundSchema: z.ZodEnum<typeof AnthropicPlainTextSourceMediaType>;
 /** @internal */
+export declare const AnthropicPlainTextSourceType$inboundSchema: z.ZodEnum<typeof AnthropicPlainTextSourceType>;
+/** @internal */
+export declare const AnthropicPlainTextSourceType$outboundSchema: z.ZodEnum<typeof AnthropicPlainTextSourceType>;
+/** @internal */
+export declare const AnthropicPlainTextSource$inboundSchema: z.ZodType<AnthropicPlainTextSource, unknown>;
+/** @internal */
 export type AnthropicPlainTextSource$Outbound = {
     data: string;
     media_type: string;
-    type: "text";
+    type: string;
 };
 /** @internal */
 export declare const AnthropicPlainTextSource$outboundSchema: z.ZodType<AnthropicPlainTextSource$Outbound, AnthropicPlainTextSource>;
 export declare function anthropicPlainTextSourceToJSON(anthropicPlainTextSource: AnthropicPlainTextSource): string;
+export declare function anthropicPlainTextSourceFromJSON(jsonString: string): SafeParseResult<AnthropicPlainTextSource, SDKValidationError>;
 //# sourceMappingURL=anthropicplaintextsource.d.ts.map

package/esm/models/anthropicplaintextsource.js

@@ -4,16 +4,36 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
 export const AnthropicPlainTextSourceMediaType = {
     TextPlain: "text/plain",
 };
+export const AnthropicPlainTextSourceType = {
+    Text: "text",
+};
+/** @internal */
+export const AnthropicPlainTextSourceMediaType$inboundSchema = z.enum(AnthropicPlainTextSourceMediaType);
+/** @internal */
+export const AnthropicPlainTextSourceMediaType$outboundSchema = AnthropicPlainTextSourceMediaType$inboundSchema;
 /** @internal */
-export const AnthropicPlainTextSourceMediaType$outboundSchema = z.enum(AnthropicPlainTextSourceMediaType);
+export const AnthropicPlainTextSourceType$inboundSchema = z.enum(AnthropicPlainTextSourceType);
+/** @internal */
+export const AnthropicPlainTextSourceType$outboundSchema = AnthropicPlainTextSourceType$inboundSchema;
+/** @internal */
+export const AnthropicPlainTextSource$inboundSchema = z.object({
+    data: z.string(),
+    media_type: AnthropicPlainTextSourceMediaType$inboundSchema,
+    type: AnthropicPlainTextSourceType$inboundSchema,
+}).transform((v) => {
+    return remap$(v, {
+        "media_type": "mediaType",
+    });
+});
 /** @internal */
 export const AnthropicPlainTextSource$outboundSchema = z.object({
     data: z.string(),
     mediaType: AnthropicPlainTextSourceMediaType$outboundSchema,
-    type: z.literal("text"),
+    type: AnthropicPlainTextSourceType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         mediaType: "media_type",
@@ -22,4 +42,7 @@ export const AnthropicPlainTextSource$outboundSchema = z.object({
 export function anthropicPlainTextSourceToJSON(anthropicPlainTextSource) {
     return JSON.stringify(AnthropicPlainTextSource$outboundSchema.parse(anthropicPlainTextSource));
 }
+export function anthropicPlainTextSourceFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicPlainTextSource$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicPlainTextSource' from JSON`);
+}
 //# sourceMappingURL=anthropicplaintextsource.js.map

package/esm/models/anthropicredactedthinkingblock.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicRedactedThinkingBlock = {
+    data: string;
+    type: "redacted_thinking";
+};
+/** @internal */
+export declare const AnthropicRedactedThinkingBlock$inboundSchema: z.ZodType<AnthropicRedactedThinkingBlock, unknown>;
+export declare function anthropicRedactedThinkingBlockFromJSON(jsonString: string): SafeParseResult<AnthropicRedactedThinkingBlock, SDKValidationError>;
+//# sourceMappingURL=anthropicredactedthinkingblock.d.ts.map

package/esm/models/anthropicredactedthinkingblock.js

@@ -0,0 +1,15 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 9217d8bb8656
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicRedactedThinkingBlock$inboundSchema = z.object({
+    data: z.string(),
+    type: z.literal("redacted_thinking"),
+});
+export function anthropicRedactedThinkingBlockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicRedactedThinkingBlock$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicRedactedThinkingBlock' from JSON`);
+}
+//# sourceMappingURL=anthropicredactedthinkingblock.js.map

package/esm/models/anthropicrefusalstopdetails.d.ts

@@ -0,0 +1,32 @@
+import * as z from "zod/v4";
+import { ClosedEnum, OpenEnum } from "../types/enums.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export declare const AnthropicRefusalStopDetailsCategory: {
+    readonly Cyber: "cyber";
+    readonly Bio: "bio";
+    readonly FrontierLlm: "frontier_llm";
+    readonly ReasoningExtraction: "reasoning_extraction";
+    readonly GeneralHarms: "general_harms";
+};
+export type AnthropicRefusalStopDetailsCategory = OpenEnum<typeof AnthropicRefusalStopDetailsCategory>;
+export declare const AnthropicRefusalStopDetailsType: {
+    readonly Refusal: "refusal";
+};
+export type AnthropicRefusalStopDetailsType = ClosedEnum<typeof AnthropicRefusalStopDetailsType>;
+/**
+ * Structured information about a refusal
+ */
+export type AnthropicRefusalStopDetails = {
+    category: AnthropicRefusalStopDetailsCategory | null;
+    explanation: string | null;
+    type: AnthropicRefusalStopDetailsType;
+};
+/** @internal */
+export declare const AnthropicRefusalStopDetailsCategory$inboundSchema: z.ZodType<AnthropicRefusalStopDetailsCategory, unknown>;
+/** @internal */
+export declare const AnthropicRefusalStopDetailsType$inboundSchema: z.ZodEnum<typeof AnthropicRefusalStopDetailsType>;
+/** @internal */
+export declare const AnthropicRefusalStopDetails$inboundSchema: z.ZodType<AnthropicRefusalStopDetails, unknown>;
+export declare function anthropicRefusalStopDetailsFromJSON(jsonString: string): SafeParseResult<AnthropicRefusalStopDetails, SDKValidationError>;
+//# sourceMappingURL=anthropicrefusalstopdetails.d.ts.map

package/esm/models/anthropicrefusalstopdetails.js

@@ -0,0 +1,31 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 62e4a3cb8de1
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import * as openEnums from "../types/enums.js";
+export const AnthropicRefusalStopDetailsCategory = {
+    Cyber: "cyber",
+    Bio: "bio",
+    FrontierLlm: "frontier_llm",
+    ReasoningExtraction: "reasoning_extraction",
+    GeneralHarms: "general_harms",
+};
+export const AnthropicRefusalStopDetailsType = {
+    Refusal: "refusal",
+};
+/** @internal */
+export const AnthropicRefusalStopDetailsCategory$inboundSchema = openEnums.inboundSchema(AnthropicRefusalStopDetailsCategory);
+/** @internal */
+export const AnthropicRefusalStopDetailsType$inboundSchema = z.enum(AnthropicRefusalStopDetailsType);
+/** @internal */
+export const AnthropicRefusalStopDetails$inboundSchema = z.object({
+    category: z.nullable(AnthropicRefusalStopDetailsCategory$inboundSchema),
+    explanation: z.nullable(z.string()),
+    type: AnthropicRefusalStopDetailsType$inboundSchema,
+});
+export function anthropicRefusalStopDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicRefusalStopDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicRefusalStopDetails' from JSON`);
+}
+//# sourceMappingURL=anthropicrefusalstopdetails.js.map

package/esm/models/anthropicservertoolerrorcode.d.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const AnthropicServerToolErrorCode: {
+    readonly InvalidToolInput: "invalid_tool_input";
+    readonly Unavailable: "unavailable";
+    readonly TooManyRequests: "too_many_requests";
+    readonly ExecutionTimeExceeded: "execution_time_exceeded";
+};
+export type AnthropicServerToolErrorCode = OpenEnum<typeof AnthropicServerToolErrorCode>;
+/** @internal */
+export declare const AnthropicServerToolErrorCode$inboundSchema: z.ZodType<AnthropicServerToolErrorCode, unknown>;
+//# sourceMappingURL=anthropicservertoolerrorcode.d.ts.map

package/esm/models/anthropicservertoolerrorcode.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 822c5d079562
+ */
+import * as openEnums from "../types/enums.js";
+export const AnthropicServerToolErrorCode = {
+    InvalidToolInput: "invalid_tool_input",
+    Unavailable: "unavailable",
+    TooManyRequests: "too_many_requests",
+    ExecutionTimeExceeded: "execution_time_exceeded",
+};
+/** @internal */
+export const AnthropicServerToolErrorCode$inboundSchema = openEnums.inboundSchema(AnthropicServerToolErrorCode);
+//# sourceMappingURL=anthropicservertoolerrorcode.js.map

package/esm/models/anthropicservertoolusage.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicServerToolUsage = {
+    webFetchRequests: number;
+    webSearchRequests: number;
+};
+/** @internal */
+export declare const AnthropicServerToolUsage$inboundSchema: z.ZodType<AnthropicServerToolUsage, unknown>;
+export declare function anthropicServerToolUsageFromJSON(jsonString: string): SafeParseResult<AnthropicServerToolUsage, SDKValidationError>;
+//# sourceMappingURL=anthropicservertoolusage.d.ts.map

package/esm/models/anthropicservertoolusage.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 71a8b24aad61
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicServerToolUsage$inboundSchema = z.object({
+    web_fetch_requests: z.int(),
+    web_search_requests: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "web_fetch_requests": "webFetchRequests",
+        "web_search_requests": "webSearchRequests",
+    });
+});
+export function anthropicServerToolUsageFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicServerToolUsage$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicServerToolUsage' from JSON`);
+}
+//# sourceMappingURL=anthropicservertoolusage.js.map

package/esm/models/anthropicservicetier.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { OpenEnum } from "../types/enums.js";
+export declare const AnthropicServiceTier: {
+    readonly Standard: "standard";
+    readonly Priority: "priority";
+    readonly Batch: "batch";
+};
+export type AnthropicServiceTier = OpenEnum<typeof AnthropicServiceTier>;
+/** @internal */
+export declare const AnthropicServiceTier$inboundSchema: z.ZodType<AnthropicServiceTier, unknown>;
+//# sourceMappingURL=anthropicservicetier.d.ts.map

package/esm/models/anthropicservicetier.js

@@ -0,0 +1,13 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 414847377bd6
+ */
+import * as openEnums from "../types/enums.js";
+export const AnthropicServiceTier = {
+    Standard: "standard",
+    Priority: "priority",
+    Batch: "batch",
+};
+/** @internal */
+export const AnthropicServiceTier$inboundSchema = openEnums.inboundSchema(AnthropicServiceTier);
+//# sourceMappingURL=anthropicservicetier.js.map

package/esm/models/anthropictextblock.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicTextCitation } from "./anthropictextcitation.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicTextBlock = {
+    citations: Array<AnthropicTextCitation> | null;
+    text: string;
+    type: "text";
+};
+/** @internal */
+export declare const AnthropicTextBlock$inboundSchema: z.ZodType<AnthropicTextBlock, unknown>;
+export declare function anthropicTextBlockFromJSON(jsonString: string): SafeParseResult<AnthropicTextBlock, SDKValidationError>;
+//# sourceMappingURL=anthropictextblock.d.ts.map

package/esm/models/anthropictextblock.js

@@ -0,0 +1,17 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 92842709fc4d
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicTextCitation$inboundSchema, } from "./anthropictextcitation.js";
+/** @internal */
+export const AnthropicTextBlock$inboundSchema = z.object({
+    citations: z.nullable(z.array(AnthropicTextCitation$inboundSchema)),
+    text: z.string(),
+    type: z.literal("text"),
+});
+export function anthropicTextBlockFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextBlock$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextBlock' from JSON`);
+}
+//# sourceMappingURL=anthropictextblock.js.map

package/esm/models/anthropictextcitation.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicCitationCharLocation } from "./anthropiccitationcharlocation.js";
+import { AnthropicCitationContentBlockLocation } from "./anthropiccitationcontentblocklocation.js";
+import { AnthropicCitationPageLocation } from "./anthropiccitationpagelocation.js";
+import { AnthropicCitationSearchResultLocation } from "./anthropiccitationsearchresultlocation.js";
+import { AnthropicCitationWebSearchResultLocation } from "./anthropiccitationwebsearchresultlocation.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicTextCitation = AnthropicCitationCharLocation | AnthropicCitationContentBlockLocation | AnthropicCitationPageLocation | AnthropicCitationSearchResultLocation | AnthropicCitationWebSearchResultLocation | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const AnthropicTextCitation$inboundSchema: z.ZodType<AnthropicTextCitation, unknown>;
+export declare function anthropicTextCitationFromJSON(jsonString: string): SafeParseResult<AnthropicTextCitation, SDKValidationError>;
+//# sourceMappingURL=anthropictextcitation.d.ts.map

package/esm/models/anthropictextcitation.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fe7e58a48729
+ */
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicCitationCharLocation$inboundSchema, } from "./anthropiccitationcharlocation.js";
+import { AnthropicCitationContentBlockLocation$inboundSchema, } from "./anthropiccitationcontentblocklocation.js";
+import { AnthropicCitationPageLocation$inboundSchema, } from "./anthropiccitationpagelocation.js";
+import { AnthropicCitationSearchResultLocation$inboundSchema, } from "./anthropiccitationsearchresultlocation.js";
+import { AnthropicCitationWebSearchResultLocation$inboundSchema, } from "./anthropiccitationwebsearchresultlocation.js";
+/** @internal */
+export const AnthropicTextCitation$inboundSchema = discriminatedUnion("type", {
+    char_location: AnthropicCitationCharLocation$inboundSchema,
+    content_block_location: AnthropicCitationContentBlockLocation$inboundSchema,
+    page_location: AnthropicCitationPageLocation$inboundSchema,
+    search_result_location: AnthropicCitationSearchResultLocation$inboundSchema,
+    web_search_result_location: AnthropicCitationWebSearchResultLocation$inboundSchema,
+});
+export function anthropicTextCitationFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextCitation$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextCitation' from JSON`);
+}
+//# sourceMappingURL=anthropictextcitation.js.map

package/esm/models/anthropictexteditorcodeexecutioncontent.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import * as discriminatedUnionTypes from "../types/discriminatedUnion.js";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicTextEditorCodeExecutionCreateResult } from "./anthropictexteditorcodeexecutioncreateresult.js";
+import { AnthropicTextEditorCodeExecutionStrReplaceResult } from "./anthropictexteditorcodeexecutionstrreplaceresult.js";
+import { AnthropicTextEditorCodeExecutionToolResultError } from "./anthropictexteditorcodeexecutiontoolresulterror.js";
+import { AnthropicTextEditorCodeExecutionViewResult } from "./anthropictexteditorcodeexecutionviewresult.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicTextEditorCodeExecutionContent = AnthropicTextEditorCodeExecutionCreateResult | AnthropicTextEditorCodeExecutionStrReplaceResult | AnthropicTextEditorCodeExecutionToolResultError | AnthropicTextEditorCodeExecutionViewResult | discriminatedUnionTypes.Unknown<"type">;
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionContent$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionContent, unknown>;
+export declare function anthropicTextEditorCodeExecutionContentFromJSON(jsonString: string): SafeParseResult<AnthropicTextEditorCodeExecutionContent, SDKValidationError>;
+//# sourceMappingURL=anthropictexteditorcodeexecutioncontent.d.ts.map

package/esm/models/anthropictexteditorcodeexecutioncontent.js

@@ -0,0 +1,21 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 832ee7a5e28a
+ */
+import { safeParse } from "../lib/schemas.js";
+import { discriminatedUnion } from "../types/discriminatedUnion.js";
+import { AnthropicTextEditorCodeExecutionCreateResult$inboundSchema, } from "./anthropictexteditorcodeexecutioncreateresult.js";
+import { AnthropicTextEditorCodeExecutionStrReplaceResult$inboundSchema, } from "./anthropictexteditorcodeexecutionstrreplaceresult.js";
+import { AnthropicTextEditorCodeExecutionToolResultError$inboundSchema, } from "./anthropictexteditorcodeexecutiontoolresulterror.js";
+import { AnthropicTextEditorCodeExecutionViewResult$inboundSchema, } from "./anthropictexteditorcodeexecutionviewresult.js";
+/** @internal */
+export const AnthropicTextEditorCodeExecutionContent$inboundSchema = discriminatedUnion("type", {
+    text_editor_code_execution_create_result: AnthropicTextEditorCodeExecutionCreateResult$inboundSchema,
+    text_editor_code_execution_str_replace_result: AnthropicTextEditorCodeExecutionStrReplaceResult$inboundSchema,
+    text_editor_code_execution_tool_result_error: AnthropicTextEditorCodeExecutionToolResultError$inboundSchema,
+    text_editor_code_execution_view_result: AnthropicTextEditorCodeExecutionViewResult$inboundSchema,
+});
+export function anthropicTextEditorCodeExecutionContentFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextEditorCodeExecutionContent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextEditorCodeExecutionContent' from JSON`);
+}
+//# sourceMappingURL=anthropictexteditorcodeexecutioncontent.js.map

package/esm/models/anthropictexteditorcodeexecutioncreateresult.d.ts

@@ -0,0 +1,11 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicTextEditorCodeExecutionCreateResult = {
+    isFileUpdate: boolean;
+    type: "text_editor_code_execution_create_result";
+};
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionCreateResult$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionCreateResult, unknown>;
+export declare function anthropicTextEditorCodeExecutionCreateResultFromJSON(jsonString: string): SafeParseResult<AnthropicTextEditorCodeExecutionCreateResult, SDKValidationError>;
+//# sourceMappingURL=anthropictexteditorcodeexecutioncreateresult.d.ts.map

package/esm/models/anthropictexteditorcodeexecutioncreateresult.js

@@ -0,0 +1,20 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 86635cf190c0
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicTextEditorCodeExecutionCreateResult$inboundSchema = z.object({
+    is_file_update: z.boolean(),
+    type: z.literal("text_editor_code_execution_create_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "is_file_update": "isFileUpdate",
+    });
+});
+export function anthropicTextEditorCodeExecutionCreateResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextEditorCodeExecutionCreateResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextEditorCodeExecutionCreateResult' from JSON`);
+}
+//# sourceMappingURL=anthropictexteditorcodeexecutioncreateresult.js.map

package/esm/models/anthropictexteditorcodeexecutionstrreplaceresult.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicTextEditorCodeExecutionStrReplaceResult = {
+    lines: Array<string> | null;
+    newLines: number | null;
+    newStart: number | null;
+    oldLines: number | null;
+    oldStart: number | null;
+    type: "text_editor_code_execution_str_replace_result";
+};
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionStrReplaceResult$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionStrReplaceResult, unknown>;
+export declare function anthropicTextEditorCodeExecutionStrReplaceResultFromJSON(jsonString: string): SafeParseResult<AnthropicTextEditorCodeExecutionStrReplaceResult, SDKValidationError>;
+//# sourceMappingURL=anthropictexteditorcodeexecutionstrreplaceresult.d.ts.map

package/esm/models/anthropictexteditorcodeexecutionstrreplaceresult.js

@@ -0,0 +1,28 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: fed740239a98
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const AnthropicTextEditorCodeExecutionStrReplaceResult$inboundSchema = z
+    .object({
+    lines: z.nullable(z.array(z.string())),
+    new_lines: z.nullable(z.int()),
+    new_start: z.nullable(z.int()),
+    old_lines: z.nullable(z.int()),
+    old_start: z.nullable(z.int()),
+    type: z.literal("text_editor_code_execution_str_replace_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "new_lines": "newLines",
+        "new_start": "newStart",
+        "old_lines": "oldLines",
+        "old_start": "oldStart",
+    });
+});
+export function anthropicTextEditorCodeExecutionStrReplaceResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextEditorCodeExecutionStrReplaceResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextEditorCodeExecutionStrReplaceResult' from JSON`);
+}
+//# sourceMappingURL=anthropictexteditorcodeexecutionstrreplaceresult.js.map

package/esm/models/anthropictexteditorcodeexecutiontoolresult.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { AnthropicTextEditorCodeExecutionContent } from "./anthropictexteditorcodeexecutioncontent.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type AnthropicTextEditorCodeExecutionToolResult = {
+    content: AnthropicTextEditorCodeExecutionContent;
+    toolUseId: string;
+    type: "text_editor_code_execution_tool_result";
+};
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionToolResult$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionToolResult, unknown>;
+export declare function anthropicTextEditorCodeExecutionToolResultFromJSON(jsonString: string): SafeParseResult<AnthropicTextEditorCodeExecutionToolResult, SDKValidationError>;
+//# sourceMappingURL=anthropictexteditorcodeexecutiontoolresult.d.ts.map

package/esm/models/anthropictexteditorcodeexecutiontoolresult.js

@@ -0,0 +1,22 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: aec07db74637
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { AnthropicTextEditorCodeExecutionContent$inboundSchema, } from "./anthropictexteditorcodeexecutioncontent.js";
+/** @internal */
+export const AnthropicTextEditorCodeExecutionToolResult$inboundSchema = z.object({
+    content: AnthropicTextEditorCodeExecutionContent$inboundSchema,
+    tool_use_id: z.string(),
+    type: z.literal("text_editor_code_execution_tool_result"),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_use_id": "toolUseId",
+    });
+});
+export function anthropicTextEditorCodeExecutionToolResultFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextEditorCodeExecutionToolResult$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextEditorCodeExecutionToolResult' from JSON`);
+}
+//# sourceMappingURL=anthropictexteditorcodeexecutiontoolresult.js.map

package/esm/models/anthropictexteditorcodeexecutiontoolresulterror.d.ts

@@ -0,0 +1,23 @@
+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 AnthropicTextEditorCodeExecutionToolResultErrorErrorCode: {
+    readonly InvalidToolInput: "invalid_tool_input";
+    readonly Unavailable: "unavailable";
+    readonly TooManyRequests: "too_many_requests";
+    readonly ExecutionTimeExceeded: "execution_time_exceeded";
+    readonly FileNotFound: "file_not_found";
+};
+export type AnthropicTextEditorCodeExecutionToolResultErrorErrorCode = OpenEnum<typeof AnthropicTextEditorCodeExecutionToolResultErrorErrorCode>;
+export type AnthropicTextEditorCodeExecutionToolResultError = {
+    errorCode: AnthropicTextEditorCodeExecutionToolResultErrorErrorCode;
+    errorMessage: string | null;
+    type: "text_editor_code_execution_tool_result_error";
+};
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionToolResultErrorErrorCode$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionToolResultErrorErrorCode, unknown>;
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionToolResultError$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionToolResultError, unknown>;
+export declare function anthropicTextEditorCodeExecutionToolResultErrorFromJSON(jsonString: string): SafeParseResult<AnthropicTextEditorCodeExecutionToolResultError, SDKValidationError>;
+//# sourceMappingURL=anthropictexteditorcodeexecutiontoolresulterror.d.ts.map

package/esm/models/anthropictexteditorcodeexecutiontoolresulterror.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: ccf083ba6bce
+ */
+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";
+export const AnthropicTextEditorCodeExecutionToolResultErrorErrorCode = {
+    InvalidToolInput: "invalid_tool_input",
+    Unavailable: "unavailable",
+    TooManyRequests: "too_many_requests",
+    ExecutionTimeExceeded: "execution_time_exceeded",
+    FileNotFound: "file_not_found",
+};
+/** @internal */
+export const AnthropicTextEditorCodeExecutionToolResultErrorErrorCode$inboundSchema = openEnums.inboundSchema(AnthropicTextEditorCodeExecutionToolResultErrorErrorCode);
+/** @internal */
+export const AnthropicTextEditorCodeExecutionToolResultError$inboundSchema = z
+    .object({
+    error_code: AnthropicTextEditorCodeExecutionToolResultErrorErrorCode$inboundSchema,
+    error_message: z.nullable(z.string()),
+    type: z.literal("text_editor_code_execution_tool_result_error"),
+}).transform((v) => {
+    return remap$(v, {
+        "error_code": "errorCode",
+        "error_message": "errorMessage",
+    });
+});
+export function anthropicTextEditorCodeExecutionToolResultErrorFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => AnthropicTextEditorCodeExecutionToolResultError$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'AnthropicTextEditorCodeExecutionToolResultError' from JSON`);
+}
+//# sourceMappingURL=anthropictexteditorcodeexecutiontoolresulterror.js.map

package/esm/models/anthropictexteditorcodeexecutionviewresult.d.ts

@@ -0,0 +1,24 @@
+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 FileType: {
+    readonly Text: "text";
+    readonly Image: "image";
+    readonly Pdf: "pdf";
+};
+export type FileType = OpenEnum<typeof FileType>;
+export type AnthropicTextEditorCodeExecutionViewResult = {
+    content: string;
+    fileType: FileType;
+    numLines: number | null;
+    startLine: number | null;
+    totalLines: number | null;
+    type: "text_editor_code_execution_view_result";
+};
+/** @internal */
+export declare const FileType$inboundSchema: z.ZodType<FileType, unknown>;
+/** @internal */
+export declare const AnthropicTextEditorCodeExecutionViewResult$inboundSchema: z.ZodType<AnthropicTextEditorCodeExecutionViewResult, unknown>;
+export declare function anthropicTextEditorCodeExecutionViewResultFromJSON(jsonString: string): SafeParseResult<AnthropicTextEditorCodeExecutionViewResult, SDKValidationError>;
+//# sourceMappingURL=anthropictexteditorcodeexecutionviewresult.d.ts.map