@quiverai/sdk 0.1.3

package/src/sdk/models/shared/svggeneratedraftevent.ts

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SVGGenerateDraftEventData = {
+  /**
+   * A unique identifier for the SVG generation.
+   */
+  id: string;
+  /**
+   * Partial SVG markup during streaming.
+   */
+  svg: string;
+};
+
+/**
+ * Streaming partial SVG chunks as generated by the model.
+ */
+export type SVGGenerateDraftEvent = {
+  data: SVGGenerateDraftEventData;
+  event: "svg_generate.draft";
+};
+
+/** @internal */
+export const SVGGenerateDraftEventData$inboundSchema: z.ZodType<
+  SVGGenerateDraftEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  svg: z.string(),
+});
+
+export function svgGenerateDraftEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGGenerateDraftEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGGenerateDraftEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGGenerateDraftEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SVGGenerateDraftEvent$inboundSchema: z.ZodType<
+  SVGGenerateDraftEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(z.lazy(() => SVGGenerateDraftEventData$inboundSchema)),
+  event: z.literal("svg_generate.draft"),
+});
+
+export function svgGenerateDraftEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGGenerateDraftEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGGenerateDraftEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGGenerateDraftEvent' from JSON`,
+  );
+}

package/src/sdk/models/shared/svggeneratereasoningevent.ts

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SVGGenerateReasoningEventData = {
+  /**
+   * A unique identifier for the SVG generation.
+   */
+  id: string;
+  /**
+   * Reasoning text about design decisions.
+   */
+  text: string;
+};
+
+/**
+ * Model reasoning about SVG design approach.
+ */
+export type SVGGenerateReasoningEvent = {
+  data: SVGGenerateReasoningEventData;
+  event: "svg_generate.reasoning";
+};
+
+/** @internal */
+export const SVGGenerateReasoningEventData$inboundSchema: z.ZodType<
+  SVGGenerateReasoningEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  text: z.string(),
+});
+
+export function svgGenerateReasoningEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGGenerateReasoningEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGGenerateReasoningEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGGenerateReasoningEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SVGGenerateReasoningEvent$inboundSchema: z.ZodType<
+  SVGGenerateReasoningEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(z.lazy(() => SVGGenerateReasoningEventData$inboundSchema)),
+  event: z.literal("svg_generate.reasoning"),
+});
+
+export function svgGenerateReasoningEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGGenerateReasoningEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGGenerateReasoningEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGGenerateReasoningEvent' from JSON`,
+  );
+}

package/src/sdk/models/shared/svginput.ts

@@ -0,0 +1,50 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  InputReference,
+  InputReference$Outbound,
+  InputReference$outboundSchema,
+} from "./inputreference.js";
+
+/**
+ * Input configuration for text-to-SVG generation
+ */
+export type SVGInput = {
+  /**
+   * Additional instructions for the model
+   */
+  instructions?: string | undefined;
+  /**
+   * The main text prompt describing the desired SVG
+   */
+  prompt: string;
+  /**
+   * Optional reference images to guide style/composition
+   */
+  references?: Array<InputReference> | undefined;
+};
+
+/** @internal */
+export type SVGInput$Outbound = {
+  instructions?: string | undefined;
+  prompt: string;
+  references?: Array<InputReference$Outbound> | undefined;
+};
+
+/** @internal */
+export const SVGInput$outboundSchema: z.ZodType<
+  SVGInput$Outbound,
+  z.ZodTypeDef,
+  SVGInput
+> = z.object({
+  instructions: z.string().optional(),
+  prompt: z.string(),
+  references: z.array(InputReference$outboundSchema).optional(),
+});
+
+export function svgInputToJSON(svgInput: SVGInput): string {
+  return JSON.stringify(SVGInput$outboundSchema.parse(svgInput));
+}

package/src/sdk/models/shared/svgmode.ts

@@ -0,0 +1,33 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { ClosedEnum } from "../../types/enums.js";
+
+/**
+ * The generation mode optimized for different use cases.
+ *
+ * @remarks
+ * - `icon`: Optimized for small sizes, usually square, distinct shapes
+ * - `illustration`: Optimized for scenes, larger viewports, complex details
+ * - `logo`: Optimized for uniqueness, strong silhouettes, text-compatible
+ */
+export const SVGMode = {
+  Icon: "icon",
+  Illustration: "illustration",
+  Logo: "logo",
+} as const;
+/**
+ * The generation mode optimized for different use cases.
+ *
+ * @remarks
+ * - `icon`: Optimized for small sizes, usually square, distinct shapes
+ * - `illustration`: Optimized for scenes, larger viewports, complex details
+ * - `logo`: Optimized for uniqueness, strong silhouettes, text-compatible
+ */
+export type SVGMode = ClosedEnum<typeof SVGMode>;
+
+/** @internal */
+export const SVGMode$outboundSchema: z.ZodNativeEnum<typeof SVGMode> = z
+  .nativeEnum(SVGMode);

package/src/sdk/models/shared/svgparams.ts

@@ -0,0 +1,70 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { Canvas, Canvas$Outbound, Canvas$outboundSchema } from "./canvas.js";
+import {
+  Constraints,
+  Constraints$Outbound,
+  Constraints$outboundSchema,
+} from "./constraints.js";
+import { Design, Design$Outbound, Design$outboundSchema } from "./design.js";
+import { SVGMode, SVGMode$outboundSchema } from "./svgmode.js";
+
+/**
+ * SVG-specific generation parameters for controlling canvas, design, and styling.
+ *
+ * @remarks
+ * These parameters give fine-grained control over the generated SVG output.
+ */
+export type SVGParams = {
+  /**
+   * Controls the coordinate system and "Safe Zones" to prevent clipping/bad cropping.
+   *
+   * @remarks
+   * NOTE: "mode" determines the default canvas if this is omitted.
+   */
+  canvas?: Canvas | undefined;
+  /**
+   * Limits and constraints for the generated SVG output
+   */
+  constraints?: Constraints | undefined;
+  /**
+   * Controls how the model applies aesthetics to the generated SVG
+   */
+  design?: Design | undefined;
+  /**
+   * The generation mode optimized for different use cases.
+   *
+   * @remarks
+   * - `icon`: Optimized for small sizes, usually square, distinct shapes
+   * - `illustration`: Optimized for scenes, larger viewports, complex details
+   * - `logo`: Optimized for uniqueness, strong silhouettes, text-compatible
+   */
+  mode?: SVGMode | undefined;
+};
+
+/** @internal */
+export type SVGParams$Outbound = {
+  canvas?: Canvas$Outbound | undefined;
+  constraints?: Constraints$Outbound | undefined;
+  design?: Design$Outbound | undefined;
+  mode: string;
+};
+
+/** @internal */
+export const SVGParams$outboundSchema: z.ZodType<
+  SVGParams$Outbound,
+  z.ZodTypeDef,
+  SVGParams
+> = z.object({
+  canvas: Canvas$outboundSchema.optional(),
+  constraints: Constraints$outboundSchema.optional(),
+  design: Design$outboundSchema.optional(),
+  mode: SVGMode$outboundSchema.default("icon"),
+});
+
+export function svgParamsToJSON(svgParams: SVGParams): string {
+  return JSON.stringify(SVGParams$outboundSchema.parse(svgParams));
+}

package/src/sdk/models/shared/svgresponse.ts

@@ -0,0 +1,48 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { SVGDocument, SVGDocument$inboundSchema } from "./svgdocument.js";
+import { Usage, Usage$inboundSchema } from "./usage.js";
+
+export type SVGResponse = {
+  /**
+   * Unix timestamp of when the response was created
+   */
+  created: number;
+  /**
+   * Array of generated SVG documents
+   */
+  data: Array<SVGDocument>;
+  /**
+   * A unique identifier for the SVG generation.
+   */
+  id: string;
+  usage?: Usage | undefined;
+};
+
+/** @internal */
+export const SVGResponse$inboundSchema: z.ZodType<
+  SVGResponse,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  created: z.number().int(),
+  data: z.array(SVGDocument$inboundSchema),
+  id: z.string(),
+  usage: Usage$inboundSchema.optional(),
+});
+
+export function svgResponseFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGResponse, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGResponse$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGResponse' from JSON`,
+  );
+}

package/src/sdk/models/shared/svgstreamevent.ts

@@ -0,0 +1,103 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  SVGAnimateContentEvent,
+  SVGAnimateContentEvent$inboundSchema,
+} from "./svganimatecontentevent.js";
+import {
+  SVGAnimateDraftEvent,
+  SVGAnimateDraftEvent$inboundSchema,
+} from "./svganimatedraftevent.js";
+import {
+  SVGAnimateReasoningEvent,
+  SVGAnimateReasoningEvent$inboundSchema,
+} from "./svganimatereasoningevent.js";
+import {
+  SVGEditContentEvent,
+  SVGEditContentEvent$inboundSchema,
+} from "./svgeditcontentevent.js";
+import {
+  SVGEditDraftEvent,
+  SVGEditDraftEvent$inboundSchema,
+} from "./svgeditdraftevent.js";
+import {
+  SVGEditReasoningEvent,
+  SVGEditReasoningEvent$inboundSchema,
+} from "./svgeditreasoningevent.js";
+import {
+  SVGGenerateContentEvent,
+  SVGGenerateContentEvent$inboundSchema,
+} from "./svggeneratecontentevent.js";
+import {
+  SVGGenerateDraftEvent,
+  SVGGenerateDraftEvent$inboundSchema,
+} from "./svggeneratedraftevent.js";
+import {
+  SVGGenerateReasoningEvent,
+  SVGGenerateReasoningEvent$inboundSchema,
+} from "./svggeneratereasoningevent.js";
+import {
+  SVGVectorizeContentEvent,
+  SVGVectorizeContentEvent$inboundSchema,
+} from "./svgvectorizecontentevent.js";
+import {
+  SVGVectorizeDraftEvent,
+  SVGVectorizeDraftEvent$inboundSchema,
+} from "./svgvectorizedraftevent.js";
+
+/**
+ * Streaming event for SVG operations (SSE format).
+ *
+ * @remarks
+ * Events flow in up to three phases:
+ * 1. `*.reasoning` - Model thinking about design approach (generate/edit/animate only)
+ * 2. `*.draft` - Streaming partial SVG chunks as generated
+ * 3. `*.content` - Final postprocessed, optimized SVG
+ */
+export type SVGStreamEvent =
+  | SVGAnimateContentEvent
+  | SVGAnimateDraftEvent
+  | SVGAnimateReasoningEvent
+  | SVGEditContentEvent
+  | SVGEditDraftEvent
+  | SVGEditReasoningEvent
+  | SVGGenerateContentEvent
+  | SVGGenerateDraftEvent
+  | SVGGenerateReasoningEvent
+  | SVGVectorizeContentEvent
+  | SVGVectorizeDraftEvent;
+
+/** @internal */
+export const SVGStreamEvent$inboundSchema: z.ZodType<
+  SVGStreamEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  SVGAnimateContentEvent$inboundSchema,
+  SVGAnimateDraftEvent$inboundSchema,
+  SVGAnimateReasoningEvent$inboundSchema,
+  SVGEditContentEvent$inboundSchema,
+  SVGEditDraftEvent$inboundSchema,
+  SVGEditReasoningEvent$inboundSchema,
+  SVGGenerateContentEvent$inboundSchema,
+  SVGGenerateDraftEvent$inboundSchema,
+  SVGGenerateReasoningEvent$inboundSchema,
+  SVGVectorizeContentEvent$inboundSchema,
+  SVGVectorizeDraftEvent$inboundSchema,
+]);
+
+export function svgStreamEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGStreamEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGStreamEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGStreamEvent' from JSON`,
+  );
+}

package/src/sdk/models/shared/svgvectorizecontentevent.ts

@@ -0,0 +1,77 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import { Usage, Usage$inboundSchema } from "./usage.js";
+
+export type SVGVectorizeContentEventData = {
+  /**
+   * A unique identifier for the vectorization.
+   */
+  id: string;
+  /**
+   * Complete, optimized vectorized SVG markup.
+   */
+  svg: string;
+  usage?: Usage | undefined;
+};
+
+/**
+ * Final postprocessed, optimized vectorized SVG.
+ */
+export type SVGVectorizeContentEvent = {
+  data: SVGVectorizeContentEventData;
+  event: "svg_vectorize.content";
+};
+
+/** @internal */
+export const SVGVectorizeContentEventData$inboundSchema: z.ZodType<
+  SVGVectorizeContentEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  svg: z.string(),
+  usage: Usage$inboundSchema.optional(),
+});
+
+export function svgVectorizeContentEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGVectorizeContentEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGVectorizeContentEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGVectorizeContentEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SVGVectorizeContentEvent$inboundSchema: z.ZodType<
+  SVGVectorizeContentEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(z.lazy(() => SVGVectorizeContentEventData$inboundSchema)),
+  event: z.literal("svg_vectorize.content"),
+});
+
+export function svgVectorizeContentEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGVectorizeContentEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGVectorizeContentEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGVectorizeContentEvent' from JSON`,
+  );
+}

package/src/sdk/models/shared/svgvectorizedraftevent.ts

@@ -0,0 +1,74 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { safeParse } from "../../../lib/schemas.js";
+import { Result as SafeParseResult } from "../../types/fp.js";
+import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+
+export type SVGVectorizeDraftEventData = {
+  /**
+   * A unique identifier for the vectorization.
+   */
+  id: string;
+  /**
+   * Partial SVG markup during vectorization.
+   */
+  svg: string;
+};
+
+/**
+ * Streaming partial SVG chunks during image vectorization.
+ */
+export type SVGVectorizeDraftEvent = {
+  data: SVGVectorizeDraftEventData;
+  event: "svg_vectorize.draft";
+};
+
+/** @internal */
+export const SVGVectorizeDraftEventData$inboundSchema: z.ZodType<
+  SVGVectorizeDraftEventData,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  svg: z.string(),
+});
+
+export function svgVectorizeDraftEventDataFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGVectorizeDraftEventData, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGVectorizeDraftEventData$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGVectorizeDraftEventData' from JSON`,
+  );
+}
+
+/** @internal */
+export const SVGVectorizeDraftEvent$inboundSchema: z.ZodType<
+  SVGVectorizeDraftEvent,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  data: z.string().transform((v, ctx) => {
+    try {
+      return JSON.parse(v);
+    } catch (err) {
+      ctx.addIssue({ code: "custom", message: `malformed json: ${err}` });
+      return z.NEVER;
+    }
+  }).pipe(z.lazy(() => SVGVectorizeDraftEventData$inboundSchema)),
+  event: z.literal("svg_vectorize.draft"),
+});
+
+export function svgVectorizeDraftEventFromJSON(
+  jsonString: string,
+): SafeParseResult<SVGVectorizeDraftEvent, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => SVGVectorizeDraftEvent$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'SVGVectorizeDraftEvent' from JSON`,
+  );
+}

package/src/sdk/models/shared/svgvectorizeinput.ts

@@ -0,0 +1,45 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import {
+  InputReference,
+  InputReference$Outbound,
+  InputReference$outboundSchema,
+} from "./inputreference.js";
+
+/**
+ * Input configuration for image-to-SVG vectorization
+ */
+export type SVGVectorizeInput = {
+  image: InputReference;
+  /**
+   * Optional instructions for vectorization style
+   */
+  instructions?: string | undefined;
+};
+
+/** @internal */
+export type SVGVectorizeInput$Outbound = {
+  image: InputReference$Outbound;
+  instructions?: string | undefined;
+};
+
+/** @internal */
+export const SVGVectorizeInput$outboundSchema: z.ZodType<
+  SVGVectorizeInput$Outbound,
+  z.ZodTypeDef,
+  SVGVectorizeInput
+> = z.object({
+  image: InputReference$outboundSchema,
+  instructions: z.string().optional(),
+});
+
+export function svgVectorizeInputToJSON(
+  svgVectorizeInput: SVGVectorizeInput,
+): string {
+  return JSON.stringify(
+    SVGVectorizeInput$outboundSchema.parse(svgVectorizeInput),
+  );
+}