@openrouter/sdk 0.13.7 → 0.13.13

package/esm/models/chatusage.js

@@ -7,7 +7,7 @@ import { remap as remap$ } from "../lib/primitives.js";
 import { safeParse } from "../lib/schemas.js";
 import { CostDetails$inboundSchema } from "./costdetails.js";
 /** @internal */
-export const CompletionTokensDetails$inboundSchema = z.object({
+export const ChatUsageCompletionTokensDetails$inboundSchema = z.object({
     accepted_prediction_tokens: z.nullable(z.int()).optional(),
     audio_tokens: z.nullable(z.int()).optional(),
     reasoning_tokens: z.nullable(z.int()).optional(),
@@ -20,11 +20,11 @@ export const CompletionTokensDetails$inboundSchema = z.object({
         "rejected_prediction_tokens": "rejectedPredictionTokens",
     });
 });
-export function completionTokensDetailsFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => CompletionTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'CompletionTokensDetails' from JSON`);
+export function chatUsageCompletionTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatUsageCompletionTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatUsageCompletionTokensDetails' from JSON`);
 }
 /** @internal */
-export const PromptTokensDetails$inboundSchema = z.object({
+export const ChatUsagePromptTokensDetails$inboundSchema = z.object({
     audio_tokens: z.int().optional(),
     cache_write_tokens: z.int().optional(),
     cached_tokens: z.int().optional(),
@@ -37,18 +37,34 @@ export const PromptTokensDetails$inboundSchema = z.object({
         "video_tokens": "videoTokens",
     });
 });
-export function promptTokensDetailsFromJSON(jsonString) {
-    return safeParse(jsonString, (x) => PromptTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'PromptTokensDetails' from JSON`);
+export function chatUsagePromptTokensDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ChatUsagePromptTokensDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ChatUsagePromptTokensDetails' from JSON`);
+}
+/** @internal */
+export const ServerToolUseDetails$inboundSchema = z.object({
+    tool_calls_executed: z.nullable(z.int()).optional(),
+    tool_calls_requested: z.nullable(z.int()).optional(),
+    web_search_requests: z.nullable(z.int()).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "tool_calls_executed": "toolCallsExecuted",
+        "tool_calls_requested": "toolCallsRequested",
+        "web_search_requests": "webSearchRequests",
+    });
+});
+export function serverToolUseDetailsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ServerToolUseDetails$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ServerToolUseDetails' from JSON`);
 }
 /** @internal */
 export const ChatUsage$inboundSchema = z.object({
     completion_tokens: z.int(),
-    completion_tokens_details: z.nullable(z.lazy(() => CompletionTokensDetails$inboundSchema)).optional(),
+    completion_tokens_details: z.nullable(z.lazy(() => ChatUsageCompletionTokensDetails$inboundSchema)).optional(),
     cost: z.nullable(z.number()).optional(),
     cost_details: z.nullable(CostDetails$inboundSchema).optional(),
     is_byok: z.boolean().optional(),
     prompt_tokens: z.int(),
-    prompt_tokens_details: z.nullable(z.lazy(() => PromptTokensDetails$inboundSchema)).optional(),
+    prompt_tokens_details: z.nullable(z.lazy(() => ChatUsagePromptTokensDetails$inboundSchema)).optional(),
+    server_tool_use_details: z.nullable(z.lazy(() => ServerToolUseDetails$inboundSchema)).optional(),
     total_tokens: z.int(),
 }).transform((v) => {
     return remap$(v, {
@@ -58,6 +74,7 @@ export const ChatUsage$inboundSchema = z.object({
         "is_byok": "isByok",
         "prompt_tokens": "promptTokens",
         "prompt_tokens_details": "promptTokensDetails",
+        "server_tool_use_details": "serverToolUseDetails",
         "total_tokens": "totalTokens",
     });
 });

package/esm/models/chatwebsearchshorthand.d.ts

@@ -32,7 +32,7 @@ export type ChatWebSearchShorthand = {
      */
     maxCharacters?: number | undefined;
     /**
-     * Maximum number of search results to return per search call. Defaults to 5. Applies to Exa, Firecrawl, Parallel, and Perplexity engines; ignored with native provider search.
+     * Maximum number of search results to return per search call. Defaults to 5. Applies to Exa, Firecrawl, Parallel, and Perplexity engines; ignored with native provider search. Perplexity supports a maximum of 20; values above 20 are clamped.
      */
     maxResults?: number | undefined;
     /**

package/esm/models/contentpartimage.d.ts

@@ -1,10 +1,15 @@
 import * as z from "zod/v4";
+import { ClosedEnum } from "../types/enums.js";
 export type ContentPartImageImageUrl = {
     url: string;
 };
+export declare const ContentPartImageType: {
+    readonly ImageUrl: "image_url";
+};
+export type ContentPartImageType = ClosedEnum<typeof ContentPartImageType>;
 export type ContentPartImage = {
     imageUrl: ContentPartImageImageUrl;
-    type: "image_url";
+    type: ContentPartImageType;
 };
 /** @internal */
 export type ContentPartImageImageUrl$Outbound = {
@@ -14,9 +19,11 @@ export type ContentPartImageImageUrl$Outbound = {
 export declare const ContentPartImageImageUrl$outboundSchema: z.ZodType<ContentPartImageImageUrl$Outbound, ContentPartImageImageUrl>;
 export declare function contentPartImageImageUrlToJSON(contentPartImageImageUrl: ContentPartImageImageUrl): string;
 /** @internal */
+export declare const ContentPartImageType$outboundSchema: z.ZodEnum<typeof ContentPartImageType>;
+/** @internal */
 export type ContentPartImage$Outbound = {
     image_url: ContentPartImageImageUrl$Outbound;
-    type: "image_url";
+    type: string;
 };
 /** @internal */
 export declare const ContentPartImage$outboundSchema: z.ZodType<ContentPartImage$Outbound, ContentPartImage>;

package/esm/models/contentpartimage.js

@@ -4,6 +4,9 @@
  */
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
+export const ContentPartImageType = {
+    ImageUrl: "image_url",
+};
 /** @internal */
 export const ContentPartImageImageUrl$outboundSchema = z.object({
     url: z.string(),
@@ -12,9 +15,11 @@ export function contentPartImageImageUrlToJSON(contentPartImageImageUrl) {
     return JSON.stringify(ContentPartImageImageUrl$outboundSchema.parse(contentPartImageImageUrl));
 }
 /** @internal */
+export const ContentPartImageType$outboundSchema = z.enum(ContentPartImageType);
+/** @internal */
 export const ContentPartImage$outboundSchema = z.object({
     imageUrl: z.lazy(() => ContentPartImageImageUrl$outboundSchema),
-    type: z.literal("image_url"),
+    type: ContentPartImageType$outboundSchema,
 }).transform((v) => {
     return remap$(v, {
         imageUrl: "image_url",

package/esm/models/debugevent.d.ts

@@ -0,0 +1,42 @@
+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 Event: {
+    readonly AdapterRequest: "adapter_request";
+    readonly UpstreamHeadersReceived: "upstream_headers_received";
+    readonly FirstTokenReceived: "first_token_received";
+    readonly UpstreamBodyEnded: "upstream_body_ended";
+};
+export type Event = OpenEnum<typeof Event>;
+export type Timings = {
+    epochMs: number;
+    event: Event;
+    startMs: number;
+};
+export type Debug = {
+    echoUpstreamBody?: {
+        [k: string]: any | null;
+    } | undefined;
+    timings?: Timings | undefined;
+};
+/**
+ * Debug event emitted when debug.echo_upstream_body is true. Contains the transformed upstream request body or timing milestones.
+ */
+export type DebugEvent = {
+    debug: Debug;
+    sequenceNumber: number;
+    type: "response.debug";
+};
+/** @internal */
+export declare const Event$inboundSchema: z.ZodType<Event, unknown>;
+/** @internal */
+export declare const Timings$inboundSchema: z.ZodType<Timings, unknown>;
+export declare function timingsFromJSON(jsonString: string): SafeParseResult<Timings, SDKValidationError>;
+/** @internal */
+export declare const Debug$inboundSchema: z.ZodType<Debug, unknown>;
+export declare function debugFromJSON(jsonString: string): SafeParseResult<Debug, SDKValidationError>;
+/** @internal */
+export declare const DebugEvent$inboundSchema: z.ZodType<DebugEvent, unknown>;
+export declare function debugEventFromJSON(jsonString: string): SafeParseResult<DebugEvent, SDKValidationError>;
+//# sourceMappingURL=debugevent.d.ts.map

package/esm/models/debugevent.js

@@ -0,0 +1,58 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: 8afa2111f54c
+ */
+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 Event = {
+    AdapterRequest: "adapter_request",
+    UpstreamHeadersReceived: "upstream_headers_received",
+    FirstTokenReceived: "first_token_received",
+    UpstreamBodyEnded: "upstream_body_ended",
+};
+/** @internal */
+export const Event$inboundSchema = openEnums
+    .inboundSchema(Event);
+/** @internal */
+export const Timings$inboundSchema = z.object({
+    epoch_ms: z.int(),
+    event: Event$inboundSchema,
+    start_ms: z.int(),
+}).transform((v) => {
+    return remap$(v, {
+        "epoch_ms": "epochMs",
+        "start_ms": "startMs",
+    });
+});
+export function timingsFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Timings$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Timings' from JSON`);
+}
+/** @internal */
+export const Debug$inboundSchema = z.object({
+    echo_upstream_body: z.record(z.string(), z.nullable(z.any())).optional(),
+    timings: z.lazy(() => Timings$inboundSchema).optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "echo_upstream_body": "echoUpstreamBody",
+    });
+});
+export function debugFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => Debug$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'Debug' from JSON`);
+}
+/** @internal */
+export const DebugEvent$inboundSchema = z
+    .object({
+    debug: z.lazy(() => Debug$inboundSchema),
+    sequence_number: z.int(),
+    type: z.literal("response.debug"),
+}).transform((v) => {
+    return remap$(v, {
+        "sequence_number": "sequenceNumber",
+    });
+});
+export function debugEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DebugEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DebugEvent' from JSON`);
+}
+//# sourceMappingURL=debugevent.js.map

package/esm/models/deleteworkspacebudgetresponse.d.ts

@@ -0,0 +1,13 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+export type DeleteWorkspaceBudgetResponse = {
+    /**
+     * Confirmation that the budget was deleted (or did not exist)
+     */
+    deleted: true;
+};
+/** @internal */
+export declare const DeleteWorkspaceBudgetResponse$inboundSchema: z.ZodType<DeleteWorkspaceBudgetResponse, unknown>;
+export declare function deleteWorkspaceBudgetResponseFromJSON(jsonString: string): SafeParseResult<DeleteWorkspaceBudgetResponse, SDKValidationError>;
+//# sourceMappingURL=deleteworkspacebudgetresponse.d.ts.map

package/esm/models/deleteworkspacebudgetresponse.js

@@ -0,0 +1,14 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: abfb4f8daac9
+ */
+import * as z from "zod/v4";
+import { safeParse } from "../lib/schemas.js";
+/** @internal */
+export const DeleteWorkspaceBudgetResponse$inboundSchema = z.object({
+    deleted: z.literal(true),
+});
+export function deleteWorkspaceBudgetResponseFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => DeleteWorkspaceBudgetResponse$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'DeleteWorkspaceBudgetResponse' from JSON`);
+}
+//# sourceMappingURL=deleteworkspacebudgetresponse.js.map

package/esm/models/enumcapability.d.ts

@@ -0,0 +1,14 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+/**
+ * A parameter that accepts one of a discrete set of string values.
+ */
+export type EnumCapability = {
+    type: "enum";
+    values: Array<string>;
+};
+/** @internal */
+export declare const EnumCapability$inboundSchema: z.ZodType<EnumCapability, unknown>;
+export declare function enumCapabilityFromJSON(jsonString: string): SafeParseResult<EnumCapability, SDKValidationError>;
+//# sourceMappingURL=enumcapability.d.ts.map

package/esm/models/enumcapability.js

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

package/esm/models/fusionplugin.d.ts

@@ -6,6 +6,7 @@ import { OpenEnum } from "../types/enums.js";
 export declare const PresetEnum: {
     readonly GeneralHigh: "general-high";
     readonly GeneralBudget: "general-budget";
+    readonly GeneralFast: "general-fast";
 };
 /**
  * A curated OpenRouter fusion preset (slugs follow `<task>-<tier>`, e.g. `general-high`). Expands server-side into the preset's analysis_models panel and judge model, so callers never name individual models. Explicitly provided `analysis_models` / `model` take precedence.

package/esm/models/fusionplugin.js

@@ -11,6 +11,7 @@ import * as openEnums from "../types/enums.js";
 export const PresetEnum = {
     GeneralHigh: "general-high",
     GeneralBudget: "general-budget",
+    GeneralFast: "general-fast",
 };
 /** @internal */
 export const PresetEnum$outboundSchema = openEnums.outboundSchema(PresetEnum);

package/esm/models/fusionservertoolconfig.d.ts

@@ -1,9 +1,11 @@
 import * as z from "zod/v4";
 import { OpenEnum } from "../types/enums.js";
+import { AnthropicCacheControlDirective, AnthropicCacheControlDirective$Outbound } from "./anthropiccachecontroldirective.js";
 /**
  * Reasoning effort level for panelist and judge inner calls.
  */
 export declare const FusionServerToolConfigEffort: {
+    readonly Max: "max";
     readonly Xhigh: "xhigh";
     readonly High: "high";
     readonly Medium: "medium";
@@ -48,6 +50,10 @@ export type FusionServerToolConfig = {
      * Slugs of models to run in parallel as the analysis panel. Each model receives the user prompt with openrouter:web_search and openrouter:web_fetch enabled, then a judge model summarizes the collective output into structured analysis JSON. Capped at 8 models to bound cost amplification. Defaults to the Quality preset from /labs/fusion.
      */
     analysisModels?: Array<string> | undefined;
+    /**
+     * Enable automatic prompt caching. When set at the top level, the system automatically applies cache breakpoints to the last cacheable block in the request. Currently supported for Anthropic Claude models.
+     */
+    cacheControl?: AnthropicCacheControlDirective | undefined;
     /**
      * Maximum number of output tokens (including reasoning tokens) each panelist and the judge model may produce per inner call. Controls the total output budget so reasoning-heavy models like GPT-5.5 do not exhaust their token allowance before producing visible text. When omitted, the provider's default applies.
      */
@@ -65,7 +71,7 @@ export type FusionServerToolConfig = {
      */
     reasoning?: FusionServerToolConfigReasoning | undefined;
     /**
-     * Sampling temperature forwarded to panelist and judge inner calls. When omitted, the provider's default applies.
+     * Temperature forwarded to panelist inner calls. The judge always runs at temperature 0 regardless of this value. When omitted, the provider's default applies.
      */
     temperature?: number | undefined;
     /**
@@ -96,6 +102,7 @@ export declare function fusionServerToolConfigToolToJSON(fusionServerToolConfigT
 /** @internal */
 export type FusionServerToolConfig$Outbound = {
     analysis_models?: Array<string> | undefined;
+    cache_control?: AnthropicCacheControlDirective$Outbound | undefined;
     max_completion_tokens?: number | undefined;
     max_tool_calls?: number | undefined;
     model?: string | undefined;

package/esm/models/fusionservertoolconfig.js

@@ -5,10 +5,12 @@
 import * as z from "zod/v4";
 import { remap as remap$ } from "../lib/primitives.js";
 import * as openEnums from "../types/enums.js";
+import { AnthropicCacheControlDirective$outboundSchema, } from "./anthropiccachecontroldirective.js";
 /**
  * Reasoning effort level for panelist and judge inner calls.
  */
 export const FusionServerToolConfigEffort = {
+    Max: "max",
     Xhigh: "xhigh",
     High: "high",
     Medium: "medium",
@@ -41,6 +43,7 @@ export function fusionServerToolConfigToolToJSON(fusionServerToolConfigTool) {
 /** @internal */
 export const FusionServerToolConfig$outboundSchema = z.object({
     analysisModels: z.array(z.string()).optional(),
+    cacheControl: AnthropicCacheControlDirective$outboundSchema.optional(),
     maxCompletionTokens: z.int().optional(),
     maxToolCalls: z.int().optional(),
     model: z.string().optional(),
@@ -52,6 +55,7 @@ export const FusionServerToolConfig$outboundSchema = z.object({
 }).transform((v) => {
     return remap$(v, {
         analysisModels: "analysis_models",
+        cacheControl: "cache_control",
         maxCompletionTokens: "max_completion_tokens",
         maxToolCalls: "max_tool_calls",
     });

package/esm/models/imageendpoint.d.ts

@@ -0,0 +1,41 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { CapabilityDescriptor } from "./capabilitydescriptor.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ImagePricingEntry } from "./imagepricingentry.js";
+/**
+ * An endpoint that serves a given image model.
+ */
+export type ImageEndpoint = {
+    /**
+     * Provider-specific options accepted under provider.options[provider_slug].
+     */
+    allowedPassthroughParameters: Array<string>;
+    /**
+     * Billable pricing lines for this endpoint.
+     */
+    pricing: Array<ImagePricingEntry>;
+    /**
+     * Provider display name
+     */
+    providerName: string;
+    /**
+     * Provider slug
+     */
+    providerSlug: string;
+    /**
+     * Provider tag for request-side selection
+     */
+    providerTag: string | null;
+    supportedParameters: {
+        [k: string]: CapabilityDescriptor;
+    };
+    /**
+     * Whether this endpoint supports native SSE streaming (`stream: true` in the request).
+     */
+    supportsStreaming: boolean;
+};
+/** @internal */
+export declare const ImageEndpoint$inboundSchema: z.ZodType<ImageEndpoint, unknown>;
+export declare function imageEndpointFromJSON(jsonString: string): SafeParseResult<ImageEndpoint, SDKValidationError>;
+//# sourceMappingURL=imageendpoint.d.ts.map

package/esm/models/imageendpoint.js

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: e13b5353df71
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { CapabilityDescriptor$inboundSchema, } from "./capabilitydescriptor.js";
+import { ImagePricingEntry$inboundSchema, } from "./imagepricingentry.js";
+/** @internal */
+export const ImageEndpoint$inboundSchema = z
+    .object({
+    allowed_passthrough_parameters: z.array(z.string()),
+    pricing: z.array(ImagePricingEntry$inboundSchema),
+    provider_name: z.string(),
+    provider_slug: z.string(),
+    provider_tag: z.nullable(z.string()),
+    supported_parameters: z.record(z.string(), CapabilityDescriptor$inboundSchema),
+    supports_streaming: z.boolean(),
+}).transform((v) => {
+    return remap$(v, {
+        "allowed_passthrough_parameters": "allowedPassthroughParameters",
+        "provider_name": "providerName",
+        "provider_slug": "providerSlug",
+        "provider_tag": "providerTag",
+        "supported_parameters": "supportedParameters",
+        "supports_streaming": "supportsStreaming",
+    });
+});
+export function imageEndpointFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageEndpoint$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageEndpoint' from JSON`);
+}
+//# sourceMappingURL=imageendpoint.js.map

package/esm/models/imagegencompletedevent.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/v4";
+import { Result as SafeParseResult } from "../types/fp.js";
+import { SDKValidationError } from "./errors/sdkvalidationerror.js";
+import { ImageGenerationUsage } from "./imagegenerationusage.js";
+/**
+ * Emitted when generation completes and the final image is available
+ */
+export type ImageGenCompletedEvent = {
+    /**
+     * Base64-encoded final image data
+     */
+    b64Json: string;
+    /**
+     * Unix timestamp (seconds) when the image was generated
+     */
+    created: number;
+    /**
+     * The event type
+     */
+    type: "image_generation.completed";
+    /**
+     * Token and cost usage for the image generation request, when available
+     */
+    usage?: ImageGenerationUsage | undefined;
+};
+/** @internal */
+export declare const ImageGenCompletedEvent$inboundSchema: z.ZodType<ImageGenCompletedEvent, unknown>;
+export declare function imageGenCompletedEventFromJSON(jsonString: string): SafeParseResult<ImageGenCompletedEvent, SDKValidationError>;
+//# sourceMappingURL=imagegencompletedevent.d.ts.map

package/esm/models/imagegencompletedevent.js

@@ -0,0 +1,23 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ * @generated-id: df990f384b54
+ */
+import * as z from "zod/v4";
+import { remap as remap$ } from "../lib/primitives.js";
+import { safeParse } from "../lib/schemas.js";
+import { ImageGenerationUsage$inboundSchema, } from "./imagegenerationusage.js";
+/** @internal */
+export const ImageGenCompletedEvent$inboundSchema = z.object({
+    b64_json: z.string(),
+    created: z.int(),
+    type: z.literal("image_generation.completed"),
+    usage: ImageGenerationUsage$inboundSchema.optional(),
+}).transform((v) => {
+    return remap$(v, {
+        "b64_json": "b64Json",
+    });
+});
+export function imageGenCompletedEventFromJSON(jsonString) {
+    return safeParse(jsonString, (x) => ImageGenCompletedEvent$inboundSchema.parse(JSON.parse(x)), `Failed to parse 'ImageGenCompletedEvent' from JSON`);
+}
+//# sourceMappingURL=imagegencompletedevent.js.map