@orq-ai/node 4.4.2 → 4.5.0-rc.1

package/packages/orq-rc/src/models/operations/parse.ts

@@ -1,777 +0,0 @@
-/*
- * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
- */
-
-import * as z from "zod/v3";
-import { remap as remap$ } from "../../lib/primitives.js";
-import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
-import { Result as SafeParseResult } from "../../types/fp.js";
-import { SDKValidationError } from "../errors/sdkvalidationerror.js";
-
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export const ParseChunkingRequestChunkingRequestRequestBodyReturnType = {
-  Chunks: "chunks",
-  Texts: "texts",
-} as const;
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export type ParseChunkingRequestChunkingRequestRequestBodyReturnType =
-  ClosedEnum<typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType>;
-
-/**
- * High-performance SIMD-optimized byte-level chunking. Best for large files (>1MB) where speed and memory efficiency are critical. 2x faster and 3x less memory than token-based chunking.
- */
-export type FastChunkerStrategy = {
-  /**
-   * The text content to be chunked
-   */
-  text: string;
-  /**
-   * Whether to include metadata for each chunk
-   */
-  metadata?: boolean | undefined;
-  /**
-   * Return format: chunks (with metadata) or texts (plain strings)
-   */
-  returnType?:
-    | ParseChunkingRequestChunkingRequestRequestBodyReturnType
-    | undefined;
-  strategy: "fast";
-  /**
-   * Target chunk size in bytes
-   */
-  targetSize?: number | undefined;
-  /**
-   * Single-byte delimiter characters. Each character is treated as a separate delimiter (e.g., ".?!" splits on period, question mark, or exclamation). Use escaped sequences for special chars.
-   */
-  delimiters?: string | undefined;
-  /**
-   * Multi-byte pattern for splitting (e.g., "▁" for SentencePiece tokenizers). Takes precedence over delimiters if set.
-   */
-  pattern?: string | undefined;
-  /**
-   * Attach delimiter to start of next chunk instead of end of current chunk
-   */
-  prefix?: boolean | undefined;
-  /**
-   * When true, splits at the START of consecutive delimiter runs, keeping the run with the following chunk (e.g., splits before "\n\n\n" not in the middle)
-   */
-  consecutive?: boolean | undefined;
-  /**
-   * Search forward if no delimiter found in backward search window
-   */
-  forwardFallback?: boolean | undefined;
-};
-
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export const ParseChunkingRequestChunkingRequestReturnType = {
-  Chunks: "chunks",
-  Texts: "texts",
-} as const;
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export type ParseChunkingRequestChunkingRequestReturnType = ClosedEnum<
-  typeof ParseChunkingRequestChunkingRequestReturnType
->;
-
-/**
- * Agentic LLM-powered chunker that uses AI to determine optimal split points. Best for complex documents requiring intelligent segmentation.
- */
-export type AgenticChunkerStrategy = {
-  /**
-   * The text content to be chunked
-   */
-  text: string;
-  /**
-   * Whether to include metadata for each chunk
-   */
-  metadata?: boolean | undefined;
-  /**
-   * Return format: chunks (with metadata) or texts (plain strings)
-   */
-  returnType?: ParseChunkingRequestChunkingRequestReturnType | undefined;
-  strategy: "agentic";
-  /**
-   * Model to use for chunking. (Available models)[https://docs.orq.ai/docs/proxy/supported-models#chat-models]
-   */
-  model: string;
-  /**
-   * Maximum tokens per chunk
-   */
-  chunkSize?: number | undefined;
-  /**
-   * Size of candidate splits for LLM evaluation
-   */
-  candidateSize?: number | undefined;
-  /**
-   * Minimum characters allowed per chunk
-   */
-  minCharactersPerChunk?: number | undefined;
-};
-
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export const ParseChunkingRequestChunkingReturnType = {
-  Chunks: "chunks",
-  Texts: "texts",
-} as const;
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export type ParseChunkingRequestChunkingReturnType = ClosedEnum<
-  typeof ParseChunkingRequestChunkingReturnType
->;
-
-export const Threshold2 = {
-  Auto: "auto",
-} as const;
-export type Threshold2 = ClosedEnum<typeof Threshold2>;
-
-/**
- * Similarity threshold for grouping (0-1) or "auto" for automatic detection
- */
-export type Threshold = number | Threshold2;
-
-/**
- * Chunking mode: window-based or sentence-based similarity
- */
-export const Mode = {
-  Window: "window",
-  Sentence: "sentence",
-} as const;
-/**
- * Chunking mode: window-based or sentence-based similarity
- */
-export type Mode = ClosedEnum<typeof Mode>;
-
-/**
- * Groups semantically similar sentences using embeddings. Excellent for maintaining topic coherence and context within chunks.
- */
-export type SemanticChunkerStrategy = {
-  /**
-   * The text content to be chunked
-   */
-  text: string;
-  /**
-   * Whether to include metadata for each chunk
-   */
-  metadata?: boolean | undefined;
-  /**
-   * Return format: chunks (with metadata) or texts (plain strings)
-   */
-  returnType?: ParseChunkingRequestChunkingReturnType | undefined;
-  strategy: "semantic";
-  /**
-   * Maximum tokens per chunk
-   */
-  chunkSize?: number | undefined;
-  /**
-   * Similarity threshold for grouping (0-1) or "auto" for automatic detection
-   */
-  threshold?: number | Threshold2 | undefined;
-  /**
-   * Embedding model to use for semantic similarity. (Available embedding models)[https://docs.orq.ai/docs/proxy/supported-models#embedding-models]
-   */
-  embeddingModel: string;
-  /**
-   * Number of dimensions for the embedding output. Required for text-embedding-3 models. Supported range: 256-3072 for text-embedding-3-large, 256-1536 for text-embedding-3-small.
-   */
-  dimensions?: number | undefined;
-  /**
-   * Maximum number of tokens per embedding request. Default is 8191 for text-embedding-3 models.
-   */
-  maxTokens?: number | undefined;
-  /**
-   * Chunking mode: window-based or sentence-based similarity
-   */
-  mode?: Mode | undefined;
-  /**
-   * Window size for similarity comparison
-   */
-  similarityWindow?: number | undefined;
-};
-
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export const ParseChunkingRequestReturnType = {
-  Chunks: "chunks",
-  Texts: "texts",
-} as const;
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export type ParseChunkingRequestReturnType = ClosedEnum<
-  typeof ParseChunkingRequestReturnType
->;
-
-/**
- * Recursively splits text using a hierarchy of separators (paragraphs, sentences, words). Versatile general-purpose chunker that preserves document structure.
- */
-export type RecursiveChunkerStrategy = {
-  /**
-   * The text content to be chunked
-   */
-  text: string;
-  /**
-   * Whether to include metadata for each chunk
-   */
-  metadata?: boolean | undefined;
-  /**
-   * Return format: chunks (with metadata) or texts (plain strings)
-   */
-  returnType?: ParseChunkingRequestReturnType | undefined;
-  strategy: "recursive";
-  /**
-   * Maximum tokens per chunk
-   */
-  chunkSize?: number | undefined;
-  /**
-   * Hierarchy of separators to use for splitting
-   */
-  separators?: Array<string> | undefined;
-  /**
-   * Minimum characters allowed per chunk
-   */
-  minCharactersPerChunk?: number | undefined;
-};
-
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export const ChunkingRequestReturnType = {
-  Chunks: "chunks",
-  Texts: "texts",
-} as const;
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export type ChunkingRequestReturnType = ClosedEnum<
-  typeof ChunkingRequestReturnType
->;
-
-/**
- * Splits text at sentence boundaries while respecting token limits. Ideal for maintaining semantic coherence and readability.
- */
-export type SentenceChunkerStrategy = {
-  /**
-   * The text content to be chunked
-   */
-  text: string;
-  /**
-   * Whether to include metadata for each chunk
-   */
-  metadata?: boolean | undefined;
-  /**
-   * Return format: chunks (with metadata) or texts (plain strings)
-   */
-  returnType?: ChunkingRequestReturnType | undefined;
-  strategy: "sentence";
-  /**
-   * Maximum tokens per chunk
-   */
-  chunkSize?: number | undefined;
-  /**
-   * Number of overlapping tokens between chunks
-   */
-  chunkOverlap?: number | undefined;
-  /**
-   * Minimum number of sentences per chunk
-   */
-  minSentencesPerChunk?: number | undefined;
-};
-
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export const ReturnTypeT = {
-  Chunks: "chunks",
-  Texts: "texts",
-} as const;
-/**
- * Return format: chunks (with metadata) or texts (plain strings)
- */
-export type ReturnTypeT = ClosedEnum<typeof ReturnTypeT>;
-
-/**
- * Splits text based on token count. Best for ensuring chunks fit within LLM context windows and maintaining consistent chunk sizes for embedding models.
- */
-export type TokenChunkerStrategy = {
-  /**
-   * The text content to be chunked
-   */
-  text: string;
-  /**
-   * Whether to include metadata for each chunk
-   */
-  metadata?: boolean | undefined;
-  /**
-   * Return format: chunks (with metadata) or texts (plain strings)
-   */
-  returnType?: ReturnTypeT | undefined;
-  strategy: "token";
-  /**
-   * Maximum tokens per chunk
-   */
-  chunkSize?: number | undefined;
-  /**
-   * Number of tokens to overlap between chunks
-   */
-  chunkOverlap?: number | undefined;
-};
-
-/**
- * Request payload for text chunking with strategy-specific configuration
- */
-export type ParseChunkingRequest =
-  | TokenChunkerStrategy
-  | SentenceChunkerStrategy
-  | RecursiveChunkerStrategy
-  | SemanticChunkerStrategy
-  | AgenticChunkerStrategy
-  | FastChunkerStrategy;
-
-export type ParseMetadata = {
-  startIndex: number | null;
-  endIndex: number | null;
-  tokenCount: number | null;
-};
-
-export type Chunks = {
-  /**
-   * The text content of the chunk
-   */
-  text: string;
-  /**
-   * The position index of this chunk in the sequence
-   */
-  index: number;
-  metadata?: ParseMetadata | undefined;
-};
-
-/**
- * Text successfully chunked
- */
-export type ParseResponseBody = {
-  chunks: Array<Chunks>;
-};
-
-/** @internal */
-export const ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema:
-  z.ZodNativeEnum<
-    typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType
-  > = z.nativeEnum(ParseChunkingRequestChunkingRequestRequestBodyReturnType);
-
-/** @internal */
-export type FastChunkerStrategy$Outbound = {
-  text: string;
-  metadata: boolean;
-  return_type: string;
-  strategy: "fast";
-  target_size: number;
-  delimiters: string;
-  pattern?: string | undefined;
-  prefix: boolean;
-  consecutive: boolean;
-  forward_fallback: boolean;
-};
-
-/** @internal */
-export const FastChunkerStrategy$outboundSchema: z.ZodType<
-  FastChunkerStrategy$Outbound,
-  z.ZodTypeDef,
-  FastChunkerStrategy
-> = z.object({
-  text: z.string(),
-  metadata: z.boolean().default(true),
-  returnType:
-    ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema
-      .default("chunks"),
-  strategy: z.literal("fast"),
-  targetSize: z.number().int().default(4096),
-  delimiters: z.string().default("\n.?"),
-  pattern: z.string().optional(),
-  prefix: z.boolean().default(false),
-  consecutive: z.boolean().default(false),
-  forwardFallback: z.boolean().default(false),
-}).transform((v) => {
-  return remap$(v, {
-    returnType: "return_type",
-    targetSize: "target_size",
-    forwardFallback: "forward_fallback",
-  });
-});
-
-export function fastChunkerStrategyToJSON(
-  fastChunkerStrategy: FastChunkerStrategy,
-): string {
-  return JSON.stringify(
-    FastChunkerStrategy$outboundSchema.parse(fastChunkerStrategy),
-  );
-}
-
-/** @internal */
-export const ParseChunkingRequestChunkingRequestReturnType$outboundSchema:
-  z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestReturnType> = z
-    .nativeEnum(ParseChunkingRequestChunkingRequestReturnType);
-
-/** @internal */
-export type AgenticChunkerStrategy$Outbound = {
-  text: string;
-  metadata: boolean;
-  return_type: string;
-  strategy: "agentic";
-  model: string;
-  chunk_size: number;
-  candidate_size: number;
-  min_characters_per_chunk: number;
-};
-
-/** @internal */
-export const AgenticChunkerStrategy$outboundSchema: z.ZodType<
-  AgenticChunkerStrategy$Outbound,
-  z.ZodTypeDef,
-  AgenticChunkerStrategy
-> = z.object({
-  text: z.string(),
-  metadata: z.boolean().default(true),
-  returnType: ParseChunkingRequestChunkingRequestReturnType$outboundSchema
-    .default("chunks"),
-  strategy: z.literal("agentic"),
-  model: z.string(),
-  chunkSize: z.number().int().default(1024),
-  candidateSize: z.number().int().default(128),
-  minCharactersPerChunk: z.number().int().default(24),
-}).transform((v) => {
-  return remap$(v, {
-    returnType: "return_type",
-    chunkSize: "chunk_size",
-    candidateSize: "candidate_size",
-    minCharactersPerChunk: "min_characters_per_chunk",
-  });
-});
-
-export function agenticChunkerStrategyToJSON(
-  agenticChunkerStrategy: AgenticChunkerStrategy,
-): string {
-  return JSON.stringify(
-    AgenticChunkerStrategy$outboundSchema.parse(agenticChunkerStrategy),
-  );
-}
-
-/** @internal */
-export const ParseChunkingRequestChunkingReturnType$outboundSchema:
-  z.ZodNativeEnum<typeof ParseChunkingRequestChunkingReturnType> = z.nativeEnum(
-    ParseChunkingRequestChunkingReturnType,
-  );
-
-/** @internal */
-export const Threshold2$outboundSchema: z.ZodNativeEnum<typeof Threshold2> = z
-  .nativeEnum(Threshold2);
-
-/** @internal */
-export type Threshold$Outbound = number | string;
-
-/** @internal */
-export const Threshold$outboundSchema: z.ZodType<
-  Threshold$Outbound,
-  z.ZodTypeDef,
-  Threshold
-> = z.union([z.number(), Threshold2$outboundSchema]);
-
-export function thresholdToJSON(threshold: Threshold): string {
-  return JSON.stringify(Threshold$outboundSchema.parse(threshold));
-}
-
-/** @internal */
-export const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
-  Mode,
-);
-
-/** @internal */
-export type SemanticChunkerStrategy$Outbound = {
-  text: string;
-  metadata: boolean;
-  return_type: string;
-  strategy: "semantic";
-  chunk_size: number;
-  threshold?: number | string | undefined;
-  embedding_model: string;
-  dimensions?: number | undefined;
-  max_tokens?: number | undefined;
-  mode: string;
-  similarity_window: number;
-};
-
-/** @internal */
-export const SemanticChunkerStrategy$outboundSchema: z.ZodType<
-  SemanticChunkerStrategy$Outbound,
-  z.ZodTypeDef,
-  SemanticChunkerStrategy
-> = z.object({
-  text: z.string(),
-  metadata: z.boolean().default(true),
-  returnType: ParseChunkingRequestChunkingReturnType$outboundSchema.default(
-    "chunks",
-  ),
-  strategy: z.literal("semantic"),
-  chunkSize: z.number().int().default(512),
-  threshold: z.union([z.number(), Threshold2$outboundSchema]).optional(),
-  embeddingModel: z.string(),
-  dimensions: z.number().int().optional(),
-  maxTokens: z.number().int().optional(),
-  mode: Mode$outboundSchema.default("window"),
-  similarityWindow: z.number().int().default(1),
-}).transform((v) => {
-  return remap$(v, {
-    returnType: "return_type",
-    chunkSize: "chunk_size",
-    embeddingModel: "embedding_model",
-    maxTokens: "max_tokens",
-    similarityWindow: "similarity_window",
-  });
-});
-
-export function semanticChunkerStrategyToJSON(
-  semanticChunkerStrategy: SemanticChunkerStrategy,
-): string {
-  return JSON.stringify(
-    SemanticChunkerStrategy$outboundSchema.parse(semanticChunkerStrategy),
-  );
-}
-
-/** @internal */
-export const ParseChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<
-  typeof ParseChunkingRequestReturnType
-> = z.nativeEnum(ParseChunkingRequestReturnType);
-
-/** @internal */
-export type RecursiveChunkerStrategy$Outbound = {
-  text: string;
-  metadata: boolean;
-  return_type: string;
-  strategy: "recursive";
-  chunk_size: number;
-  separators?: Array<string> | undefined;
-  min_characters_per_chunk: number;
-};
-
-/** @internal */
-export const RecursiveChunkerStrategy$outboundSchema: z.ZodType<
-  RecursiveChunkerStrategy$Outbound,
-  z.ZodTypeDef,
-  RecursiveChunkerStrategy
-> = z.object({
-  text: z.string(),
-  metadata: z.boolean().default(true),
-  returnType: ParseChunkingRequestReturnType$outboundSchema.default("chunks"),
-  strategy: z.literal("recursive"),
-  chunkSize: z.number().int().default(512),
-  separators: z.array(z.string()).optional(),
-  minCharactersPerChunk: z.number().int().default(24),
-}).transform((v) => {
-  return remap$(v, {
-    returnType: "return_type",
-    chunkSize: "chunk_size",
-    minCharactersPerChunk: "min_characters_per_chunk",
-  });
-});
-
-export function recursiveChunkerStrategyToJSON(
-  recursiveChunkerStrategy: RecursiveChunkerStrategy,
-): string {
-  return JSON.stringify(
-    RecursiveChunkerStrategy$outboundSchema.parse(recursiveChunkerStrategy),
-  );
-}
-
-/** @internal */
-export const ChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<
-  typeof ChunkingRequestReturnType
-> = z.nativeEnum(ChunkingRequestReturnType);
-
-/** @internal */
-export type SentenceChunkerStrategy$Outbound = {
-  text: string;
-  metadata: boolean;
-  return_type: string;
-  strategy: "sentence";
-  chunk_size: number;
-  chunk_overlap: number;
-  min_sentences_per_chunk: number;
-};
-
-/** @internal */
-export const SentenceChunkerStrategy$outboundSchema: z.ZodType<
-  SentenceChunkerStrategy$Outbound,
-  z.ZodTypeDef,
-  SentenceChunkerStrategy
-> = z.object({
-  text: z.string(),
-  metadata: z.boolean().default(true),
-  returnType: ChunkingRequestReturnType$outboundSchema.default("chunks"),
-  strategy: z.literal("sentence"),
-  chunkSize: z.number().int().default(512),
-  chunkOverlap: z.number().int().default(0),
-  minSentencesPerChunk: z.number().int().default(1),
-}).transform((v) => {
-  return remap$(v, {
-    returnType: "return_type",
-    chunkSize: "chunk_size",
-    chunkOverlap: "chunk_overlap",
-    minSentencesPerChunk: "min_sentences_per_chunk",
-  });
-});
-
-export function sentenceChunkerStrategyToJSON(
-  sentenceChunkerStrategy: SentenceChunkerStrategy,
-): string {
-  return JSON.stringify(
-    SentenceChunkerStrategy$outboundSchema.parse(sentenceChunkerStrategy),
-  );
-}
-
-/** @internal */
-export const ReturnTypeT$outboundSchema: z.ZodNativeEnum<typeof ReturnTypeT> = z
-  .nativeEnum(ReturnTypeT);
-
-/** @internal */
-export type TokenChunkerStrategy$Outbound = {
-  text: string;
-  metadata: boolean;
-  return_type: string;
-  strategy: "token";
-  chunk_size: number;
-  chunk_overlap: number;
-};
-
-/** @internal */
-export const TokenChunkerStrategy$outboundSchema: z.ZodType<
-  TokenChunkerStrategy$Outbound,
-  z.ZodTypeDef,
-  TokenChunkerStrategy
-> = z.object({
-  text: z.string(),
-  metadata: z.boolean().default(true),
-  returnType: ReturnTypeT$outboundSchema.default("chunks"),
-  strategy: z.literal("token"),
-  chunkSize: z.number().int().default(512),
-  chunkOverlap: z.number().int().default(0),
-}).transform((v) => {
-  return remap$(v, {
-    returnType: "return_type",
-    chunkSize: "chunk_size",
-    chunkOverlap: "chunk_overlap",
-  });
-});
-
-export function tokenChunkerStrategyToJSON(
-  tokenChunkerStrategy: TokenChunkerStrategy,
-): string {
-  return JSON.stringify(
-    TokenChunkerStrategy$outboundSchema.parse(tokenChunkerStrategy),
-  );
-}
-
-/** @internal */
-export type ParseChunkingRequest$Outbound =
-  | TokenChunkerStrategy$Outbound
-  | SentenceChunkerStrategy$Outbound
-  | RecursiveChunkerStrategy$Outbound
-  | SemanticChunkerStrategy$Outbound
-  | AgenticChunkerStrategy$Outbound
-  | FastChunkerStrategy$Outbound;
-
-/** @internal */
-export const ParseChunkingRequest$outboundSchema: z.ZodType<
-  ParseChunkingRequest$Outbound,
-  z.ZodTypeDef,
-  ParseChunkingRequest
-> = z.union([
-  z.lazy(() => TokenChunkerStrategy$outboundSchema),
-  z.lazy(() => SentenceChunkerStrategy$outboundSchema),
-  z.lazy(() => RecursiveChunkerStrategy$outboundSchema),
-  z.lazy(() => SemanticChunkerStrategy$outboundSchema),
-  z.lazy(() => AgenticChunkerStrategy$outboundSchema),
-  z.lazy(() => FastChunkerStrategy$outboundSchema),
-]);
-
-export function parseChunkingRequestToJSON(
-  parseChunkingRequest: ParseChunkingRequest,
-): string {
-  return JSON.stringify(
-    ParseChunkingRequest$outboundSchema.parse(parseChunkingRequest),
-  );
-}
-
-/** @internal */
-export const ParseMetadata$inboundSchema: z.ZodType<
-  ParseMetadata,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  start_index: z.nullable(z.number()),
-  end_index: z.nullable(z.number()),
-  token_count: z.nullable(z.number()),
-}).transform((v) => {
-  return remap$(v, {
-    "start_index": "startIndex",
-    "end_index": "endIndex",
-    "token_count": "tokenCount",
-  });
-});
-
-export function parseMetadataFromJSON(
-  jsonString: string,
-): SafeParseResult<ParseMetadata, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ParseMetadata$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ParseMetadata' from JSON`,
-  );
-}
-
-/** @internal */
-export const Chunks$inboundSchema: z.ZodType<Chunks, z.ZodTypeDef, unknown> = z
-  .object({
-    text: z.string(),
-    index: z.number(),
-    metadata: z.lazy(() => ParseMetadata$inboundSchema).optional(),
-  });
-
-export function chunksFromJSON(
-  jsonString: string,
-): SafeParseResult<Chunks, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Chunks$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Chunks' from JSON`,
-  );
-}
-
-/** @internal */
-export const ParseResponseBody$inboundSchema: z.ZodType<
-  ParseResponseBody,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  chunks: z.array(z.lazy(() => Chunks$inboundSchema)),
-});
-
-export function parseResponseBodyFromJSON(
-  jsonString: string,
-): SafeParseResult<ParseResponseBody, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ParseResponseBody$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ParseResponseBody' from JSON`,
-  );
-}