@orq-ai/node 3.9.6 → 3.9.7

package/models/operations/parse.d.ts

@@ -0,0 +1,961 @@
+import * as z from "zod";
+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 declare const ParseChunkingRequestChunkingRequestRequestBodyReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingRequestRequestBodyReturnType = ClosedEnum<typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType>;
+export declare const AgenticChunker: {
+    readonly Agentic: "agentic";
+};
+export type AgenticChunker = ClosedEnum<typeof AgenticChunker>;
+/**
+ * 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?: ParseChunkingRequestChunkingRequestRequestBodyReturnType | undefined;
+    strategy: AgenticChunker;
+    /**
+     * Chat model to use for chunking. (Available models)[https://docs.orq.ai/docs/proxy#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 declare const ParseChunkingRequestChunkingRequestReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingRequestReturnType = ClosedEnum<typeof ParseChunkingRequestChunkingRequestReturnType>;
+export declare const SDPMChunker: {
+    readonly Sdpm: "sdpm";
+};
+export type SDPMChunker = ClosedEnum<typeof SDPMChunker>;
+export declare const ParseThreshold2: {
+    readonly Auto: "auto";
+};
+export type ParseThreshold2 = ClosedEnum<typeof ParseThreshold2>;
+/**
+ * Similarity threshold for grouping (0-1) or "auto" for automatic detection
+ */
+export type ChunkingRequestThreshold = number | ParseThreshold2;
+/**
+ * Chunking mode: window-based or sentence-based similarity
+ */
+export declare const ChunkingRequestMode: {
+    readonly Window: "window";
+    readonly Sentence: "sentence";
+};
+/**
+ * Chunking mode: window-based or sentence-based similarity
+ */
+export type ChunkingRequestMode = ClosedEnum<typeof ChunkingRequestMode>;
+/**
+ * Sub-Document Prose Model chunker that uses skip-gram patterns to identify optimal split points. Good for technical documents with structured content.
+ */
+export type SDPMChunkerStrategy = {
+    /**
+     * 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: SDPMChunker;
+    /**
+     * Maximum tokens per chunk
+     */
+    chunkSize?: number | undefined;
+    /**
+     * Window size for skip-gram patterns
+     */
+    skipWindow?: number | undefined;
+    /**
+     * Similarity threshold for grouping (0-1) or "auto" for automatic detection
+     */
+    threshold?: number | ParseThreshold2 | undefined;
+    /**
+     * Embedding model to use for semantic similarity. (Available embedding models)[https://docs.orq.ai/docs/proxy#embedding-models]
+     */
+    embeddingModel: string;
+    /**
+     * Chunking mode: window-based or sentence-based similarity
+     */
+    mode?: ChunkingRequestMode | undefined;
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export declare const ParseChunkingRequestChunkingReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestChunkingReturnType = ClosedEnum<typeof ParseChunkingRequestChunkingReturnType>;
+export declare const SemanticChunker: {
+    readonly Semantic: "semantic";
+};
+export type SemanticChunker = ClosedEnum<typeof SemanticChunker>;
+export declare const Threshold2: {
+    readonly Auto: "auto";
+};
+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 declare const Mode: {
+    readonly Window: "window";
+    readonly Sentence: "sentence";
+};
+/**
+ * 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: SemanticChunker;
+    /**
+     * 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#embedding-models]
+     */
+    embeddingModel: string;
+    /**
+     * 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 declare const ParseChunkingRequestReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ParseChunkingRequestReturnType = ClosedEnum<typeof ParseChunkingRequestReturnType>;
+export declare const RecursiveChunker: {
+    readonly Recursive: "recursive";
+};
+export type RecursiveChunker = ClosedEnum<typeof RecursiveChunker>;
+/**
+ * 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: RecursiveChunker;
+    /**
+     * 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 declare const ChunkingRequestReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ChunkingRequestReturnType = ClosedEnum<typeof ChunkingRequestReturnType>;
+export declare const SentenceChunker: {
+    readonly Sentence: "sentence";
+};
+export type SentenceChunker = ClosedEnum<typeof SentenceChunker>;
+/**
+ * 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: SentenceChunker;
+    /**
+     * 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 declare const ReturnTypeT: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ReturnTypeT = ClosedEnum<typeof ReturnTypeT>;
+export declare const TokenChunker: {
+    readonly Token: "token";
+};
+export type TokenChunker = ClosedEnum<typeof TokenChunker>;
+/**
+ * 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: TokenChunker;
+    /**
+     * 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 = SemanticChunkerStrategy | SDPMChunkerStrategy | AgenticChunkerStrategy | TokenChunkerStrategy | SentenceChunkerStrategy | RecursiveChunkerStrategy;
+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 declare const ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType>;
+/** @internal */
+export declare const ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestRequestBodyReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseChunkingRequestChunkingRequestRequestBodyReturnType$ {
+    /** @deprecated use `ParseChunkingRequestChunkingRequestRequestBodyReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ParseChunkingRequestChunkingRequestRequestBodyReturnType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+}
+/** @internal */
+export declare const AgenticChunker$inboundSchema: z.ZodNativeEnum<typeof AgenticChunker>;
+/** @internal */
+export declare const AgenticChunker$outboundSchema: z.ZodNativeEnum<typeof AgenticChunker>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace AgenticChunker$ {
+    /** @deprecated use `AgenticChunker$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Agentic: "agentic";
+    }>;
+    /** @deprecated use `AgenticChunker$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Agentic: "agentic";
+    }>;
+}
+/** @internal */
+export declare const AgenticChunkerStrategy$inboundSchema: z.ZodType<AgenticChunkerStrategy, z.ZodTypeDef, unknown>;
+/** @internal */
+export type AgenticChunkerStrategy$Outbound = {
+    text: string;
+    metadata: boolean;
+    return_type: string;
+    strategy: string;
+    model: string;
+    chunk_size: number;
+    candidate_size: number;
+    min_characters_per_chunk: number;
+};
+/** @internal */
+export declare const AgenticChunkerStrategy$outboundSchema: z.ZodType<AgenticChunkerStrategy$Outbound, z.ZodTypeDef, AgenticChunkerStrategy>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace AgenticChunkerStrategy$ {
+    /** @deprecated use `AgenticChunkerStrategy$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<AgenticChunkerStrategy, z.ZodTypeDef, unknown>;
+    /** @deprecated use `AgenticChunkerStrategy$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<AgenticChunkerStrategy$Outbound, z.ZodTypeDef, AgenticChunkerStrategy>;
+    /** @deprecated use `AgenticChunkerStrategy$Outbound` instead. */
+    type Outbound = AgenticChunkerStrategy$Outbound;
+}
+export declare function agenticChunkerStrategyToJSON(agenticChunkerStrategy: AgenticChunkerStrategy): string;
+export declare function agenticChunkerStrategyFromJSON(jsonString: string): SafeParseResult<AgenticChunkerStrategy, SDKValidationError>;
+/** @internal */
+export declare const ParseChunkingRequestChunkingRequestReturnType$inboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestReturnType>;
+/** @internal */
+export declare const ParseChunkingRequestChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestChunkingRequestReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseChunkingRequestChunkingRequestReturnType$ {
+    /** @deprecated use `ParseChunkingRequestChunkingRequestReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ParseChunkingRequestChunkingRequestReturnType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+}
+/** @internal */
+export declare const SDPMChunker$inboundSchema: z.ZodNativeEnum<typeof SDPMChunker>;
+/** @internal */
+export declare const SDPMChunker$outboundSchema: z.ZodNativeEnum<typeof SDPMChunker>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SDPMChunker$ {
+    /** @deprecated use `SDPMChunker$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Sdpm: "sdpm";
+    }>;
+    /** @deprecated use `SDPMChunker$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Sdpm: "sdpm";
+    }>;
+}
+/** @internal */
+export declare const ParseThreshold2$inboundSchema: z.ZodNativeEnum<typeof ParseThreshold2>;
+/** @internal */
+export declare const ParseThreshold2$outboundSchema: z.ZodNativeEnum<typeof ParseThreshold2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseThreshold2$ {
+    /** @deprecated use `ParseThreshold2$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Auto: "auto";
+    }>;
+    /** @deprecated use `ParseThreshold2$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Auto: "auto";
+    }>;
+}
+/** @internal */
+export declare const ChunkingRequestThreshold$inboundSchema: z.ZodType<ChunkingRequestThreshold, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ChunkingRequestThreshold$Outbound = number | string;
+/** @internal */
+export declare const ChunkingRequestThreshold$outboundSchema: z.ZodType<ChunkingRequestThreshold$Outbound, z.ZodTypeDef, ChunkingRequestThreshold>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkingRequestThreshold$ {
+    /** @deprecated use `ChunkingRequestThreshold$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChunkingRequestThreshold, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ChunkingRequestThreshold$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChunkingRequestThreshold$Outbound, z.ZodTypeDef, ChunkingRequestThreshold>;
+    /** @deprecated use `ChunkingRequestThreshold$Outbound` instead. */
+    type Outbound = ChunkingRequestThreshold$Outbound;
+}
+export declare function chunkingRequestThresholdToJSON(chunkingRequestThreshold: ChunkingRequestThreshold): string;
+export declare function chunkingRequestThresholdFromJSON(jsonString: string): SafeParseResult<ChunkingRequestThreshold, SDKValidationError>;
+/** @internal */
+export declare const ChunkingRequestMode$inboundSchema: z.ZodNativeEnum<typeof ChunkingRequestMode>;
+/** @internal */
+export declare const ChunkingRequestMode$outboundSchema: z.ZodNativeEnum<typeof ChunkingRequestMode>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkingRequestMode$ {
+    /** @deprecated use `ChunkingRequestMode$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Window: "window";
+        readonly Sentence: "sentence";
+    }>;
+    /** @deprecated use `ChunkingRequestMode$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Window: "window";
+        readonly Sentence: "sentence";
+    }>;
+}
+/** @internal */
+export declare const SDPMChunkerStrategy$inboundSchema: z.ZodType<SDPMChunkerStrategy, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SDPMChunkerStrategy$Outbound = {
+    text: string;
+    metadata: boolean;
+    return_type: string;
+    strategy: string;
+    chunk_size: number;
+    skip_window: number;
+    threshold?: number | string | undefined;
+    embedding_model: string;
+    mode: string;
+};
+/** @internal */
+export declare const SDPMChunkerStrategy$outboundSchema: z.ZodType<SDPMChunkerStrategy$Outbound, z.ZodTypeDef, SDPMChunkerStrategy>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SDPMChunkerStrategy$ {
+    /** @deprecated use `SDPMChunkerStrategy$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<SDPMChunkerStrategy, z.ZodTypeDef, unknown>;
+    /** @deprecated use `SDPMChunkerStrategy$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<SDPMChunkerStrategy$Outbound, z.ZodTypeDef, SDPMChunkerStrategy>;
+    /** @deprecated use `SDPMChunkerStrategy$Outbound` instead. */
+    type Outbound = SDPMChunkerStrategy$Outbound;
+}
+export declare function sdpmChunkerStrategyToJSON(sdpmChunkerStrategy: SDPMChunkerStrategy): string;
+export declare function sdpmChunkerStrategyFromJSON(jsonString: string): SafeParseResult<SDPMChunkerStrategy, SDKValidationError>;
+/** @internal */
+export declare const ParseChunkingRequestChunkingReturnType$inboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestChunkingReturnType>;
+/** @internal */
+export declare const ParseChunkingRequestChunkingReturnType$outboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestChunkingReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseChunkingRequestChunkingReturnType$ {
+    /** @deprecated use `ParseChunkingRequestChunkingReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ParseChunkingRequestChunkingReturnType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+}
+/** @internal */
+export declare const SemanticChunker$inboundSchema: z.ZodNativeEnum<typeof SemanticChunker>;
+/** @internal */
+export declare const SemanticChunker$outboundSchema: z.ZodNativeEnum<typeof SemanticChunker>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SemanticChunker$ {
+    /** @deprecated use `SemanticChunker$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Semantic: "semantic";
+    }>;
+    /** @deprecated use `SemanticChunker$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Semantic: "semantic";
+    }>;
+}
+/** @internal */
+export declare const Threshold2$inboundSchema: z.ZodNativeEnum<typeof Threshold2>;
+/** @internal */
+export declare const Threshold2$outboundSchema: z.ZodNativeEnum<typeof Threshold2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Threshold2$ {
+    /** @deprecated use `Threshold2$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Auto: "auto";
+    }>;
+    /** @deprecated use `Threshold2$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Auto: "auto";
+    }>;
+}
+/** @internal */
+export declare const Threshold$inboundSchema: z.ZodType<Threshold, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Threshold$Outbound = number | string;
+/** @internal */
+export declare const Threshold$outboundSchema: z.ZodType<Threshold$Outbound, z.ZodTypeDef, Threshold>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Threshold$ {
+    /** @deprecated use `Threshold$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Threshold, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Threshold$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Threshold$Outbound, z.ZodTypeDef, Threshold>;
+    /** @deprecated use `Threshold$Outbound` instead. */
+    type Outbound = Threshold$Outbound;
+}
+export declare function thresholdToJSON(threshold: Threshold): string;
+export declare function thresholdFromJSON(jsonString: string): SafeParseResult<Threshold, SDKValidationError>;
+/** @internal */
+export declare const Mode$inboundSchema: z.ZodNativeEnum<typeof Mode>;
+/** @internal */
+export declare const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Mode$ {
+    /** @deprecated use `Mode$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Window: "window";
+        readonly Sentence: "sentence";
+    }>;
+    /** @deprecated use `Mode$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Window: "window";
+        readonly Sentence: "sentence";
+    }>;
+}
+/** @internal */
+export declare const SemanticChunkerStrategy$inboundSchema: z.ZodType<SemanticChunkerStrategy, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SemanticChunkerStrategy$Outbound = {
+    text: string;
+    metadata: boolean;
+    return_type: string;
+    strategy: string;
+    chunk_size: number;
+    threshold?: number | string | undefined;
+    embedding_model: string;
+    mode: string;
+    similarity_window: number;
+};
+/** @internal */
+export declare const SemanticChunkerStrategy$outboundSchema: z.ZodType<SemanticChunkerStrategy$Outbound, z.ZodTypeDef, SemanticChunkerStrategy>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SemanticChunkerStrategy$ {
+    /** @deprecated use `SemanticChunkerStrategy$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<SemanticChunkerStrategy, z.ZodTypeDef, unknown>;
+    /** @deprecated use `SemanticChunkerStrategy$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<SemanticChunkerStrategy$Outbound, z.ZodTypeDef, SemanticChunkerStrategy>;
+    /** @deprecated use `SemanticChunkerStrategy$Outbound` instead. */
+    type Outbound = SemanticChunkerStrategy$Outbound;
+}
+export declare function semanticChunkerStrategyToJSON(semanticChunkerStrategy: SemanticChunkerStrategy): string;
+export declare function semanticChunkerStrategyFromJSON(jsonString: string): SafeParseResult<SemanticChunkerStrategy, SDKValidationError>;
+/** @internal */
+export declare const ParseChunkingRequestReturnType$inboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestReturnType>;
+/** @internal */
+export declare const ParseChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<typeof ParseChunkingRequestReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseChunkingRequestReturnType$ {
+    /** @deprecated use `ParseChunkingRequestReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ParseChunkingRequestReturnType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+}
+/** @internal */
+export declare const RecursiveChunker$inboundSchema: z.ZodNativeEnum<typeof RecursiveChunker>;
+/** @internal */
+export declare const RecursiveChunker$outboundSchema: z.ZodNativeEnum<typeof RecursiveChunker>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace RecursiveChunker$ {
+    /** @deprecated use `RecursiveChunker$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Recursive: "recursive";
+    }>;
+    /** @deprecated use `RecursiveChunker$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Recursive: "recursive";
+    }>;
+}
+/** @internal */
+export declare const RecursiveChunkerStrategy$inboundSchema: z.ZodType<RecursiveChunkerStrategy, z.ZodTypeDef, unknown>;
+/** @internal */
+export type RecursiveChunkerStrategy$Outbound = {
+    text: string;
+    metadata: boolean;
+    return_type: string;
+    strategy: string;
+    chunk_size: number;
+    separators?: Array<string> | undefined;
+    min_characters_per_chunk: number;
+};
+/** @internal */
+export declare const RecursiveChunkerStrategy$outboundSchema: z.ZodType<RecursiveChunkerStrategy$Outbound, z.ZodTypeDef, RecursiveChunkerStrategy>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace RecursiveChunkerStrategy$ {
+    /** @deprecated use `RecursiveChunkerStrategy$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<RecursiveChunkerStrategy, z.ZodTypeDef, unknown>;
+    /** @deprecated use `RecursiveChunkerStrategy$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<RecursiveChunkerStrategy$Outbound, z.ZodTypeDef, RecursiveChunkerStrategy>;
+    /** @deprecated use `RecursiveChunkerStrategy$Outbound` instead. */
+    type Outbound = RecursiveChunkerStrategy$Outbound;
+}
+export declare function recursiveChunkerStrategyToJSON(recursiveChunkerStrategy: RecursiveChunkerStrategy): string;
+export declare function recursiveChunkerStrategyFromJSON(jsonString: string): SafeParseResult<RecursiveChunkerStrategy, SDKValidationError>;
+/** @internal */
+export declare const ChunkingRequestReturnType$inboundSchema: z.ZodNativeEnum<typeof ChunkingRequestReturnType>;
+/** @internal */
+export declare const ChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<typeof ChunkingRequestReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkingRequestReturnType$ {
+    /** @deprecated use `ChunkingRequestReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ChunkingRequestReturnType$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+}
+/** @internal */
+export declare const SentenceChunker$inboundSchema: z.ZodNativeEnum<typeof SentenceChunker>;
+/** @internal */
+export declare const SentenceChunker$outboundSchema: z.ZodNativeEnum<typeof SentenceChunker>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SentenceChunker$ {
+    /** @deprecated use `SentenceChunker$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Sentence: "sentence";
+    }>;
+    /** @deprecated use `SentenceChunker$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Sentence: "sentence";
+    }>;
+}
+/** @internal */
+export declare const SentenceChunkerStrategy$inboundSchema: z.ZodType<SentenceChunkerStrategy, z.ZodTypeDef, unknown>;
+/** @internal */
+export type SentenceChunkerStrategy$Outbound = {
+    text: string;
+    metadata: boolean;
+    return_type: string;
+    strategy: string;
+    chunk_size: number;
+    chunk_overlap: number;
+    min_sentences_per_chunk: number;
+};
+/** @internal */
+export declare const SentenceChunkerStrategy$outboundSchema: z.ZodType<SentenceChunkerStrategy$Outbound, z.ZodTypeDef, SentenceChunkerStrategy>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace SentenceChunkerStrategy$ {
+    /** @deprecated use `SentenceChunkerStrategy$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<SentenceChunkerStrategy, z.ZodTypeDef, unknown>;
+    /** @deprecated use `SentenceChunkerStrategy$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<SentenceChunkerStrategy$Outbound, z.ZodTypeDef, SentenceChunkerStrategy>;
+    /** @deprecated use `SentenceChunkerStrategy$Outbound` instead. */
+    type Outbound = SentenceChunkerStrategy$Outbound;
+}
+export declare function sentenceChunkerStrategyToJSON(sentenceChunkerStrategy: SentenceChunkerStrategy): string;
+export declare function sentenceChunkerStrategyFromJSON(jsonString: string): SafeParseResult<SentenceChunkerStrategy, SDKValidationError>;
+/** @internal */
+export declare const ReturnTypeT$inboundSchema: z.ZodNativeEnum<typeof ReturnTypeT>;
+/** @internal */
+export declare const ReturnTypeT$outboundSchema: z.ZodNativeEnum<typeof ReturnTypeT>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ReturnTypeT$ {
+    /** @deprecated use `ReturnTypeT$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ReturnTypeT$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+}
+/** @internal */
+export declare const TokenChunker$inboundSchema: z.ZodNativeEnum<typeof TokenChunker>;
+/** @internal */
+export declare const TokenChunker$outboundSchema: z.ZodNativeEnum<typeof TokenChunker>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace TokenChunker$ {
+    /** @deprecated use `TokenChunker$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Token: "token";
+    }>;
+    /** @deprecated use `TokenChunker$outboundSchema` instead. */
+    const outboundSchema: z.ZodNativeEnum<{
+        readonly Token: "token";
+    }>;
+}
+/** @internal */
+export declare const TokenChunkerStrategy$inboundSchema: z.ZodType<TokenChunkerStrategy, z.ZodTypeDef, unknown>;
+/** @internal */
+export type TokenChunkerStrategy$Outbound = {
+    text: string;
+    metadata: boolean;
+    return_type: string;
+    strategy: string;
+    chunk_size: number;
+    chunk_overlap: number;
+};
+/** @internal */
+export declare const TokenChunkerStrategy$outboundSchema: z.ZodType<TokenChunkerStrategy$Outbound, z.ZodTypeDef, TokenChunkerStrategy>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace TokenChunkerStrategy$ {
+    /** @deprecated use `TokenChunkerStrategy$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<TokenChunkerStrategy, z.ZodTypeDef, unknown>;
+    /** @deprecated use `TokenChunkerStrategy$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<TokenChunkerStrategy$Outbound, z.ZodTypeDef, TokenChunkerStrategy>;
+    /** @deprecated use `TokenChunkerStrategy$Outbound` instead. */
+    type Outbound = TokenChunkerStrategy$Outbound;
+}
+export declare function tokenChunkerStrategyToJSON(tokenChunkerStrategy: TokenChunkerStrategy): string;
+export declare function tokenChunkerStrategyFromJSON(jsonString: string): SafeParseResult<TokenChunkerStrategy, SDKValidationError>;
+/** @internal */
+export declare const ParseChunkingRequest$inboundSchema: z.ZodType<ParseChunkingRequest, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ParseChunkingRequest$Outbound = SemanticChunkerStrategy$Outbound | SDPMChunkerStrategy$Outbound | AgenticChunkerStrategy$Outbound | TokenChunkerStrategy$Outbound | SentenceChunkerStrategy$Outbound | RecursiveChunkerStrategy$Outbound;
+/** @internal */
+export declare const ParseChunkingRequest$outboundSchema: z.ZodType<ParseChunkingRequest$Outbound, z.ZodTypeDef, ParseChunkingRequest>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseChunkingRequest$ {
+    /** @deprecated use `ParseChunkingRequest$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ParseChunkingRequest, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ParseChunkingRequest$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ParseChunkingRequest$Outbound, z.ZodTypeDef, ParseChunkingRequest>;
+    /** @deprecated use `ParseChunkingRequest$Outbound` instead. */
+    type Outbound = ParseChunkingRequest$Outbound;
+}
+export declare function parseChunkingRequestToJSON(parseChunkingRequest: ParseChunkingRequest): string;
+export declare function parseChunkingRequestFromJSON(jsonString: string): SafeParseResult<ParseChunkingRequest, SDKValidationError>;
+/** @internal */
+export declare const ParseMetadata$inboundSchema: z.ZodType<ParseMetadata, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ParseMetadata$Outbound = {
+    start_index: number | null;
+    end_index: number | null;
+    token_count: number | null;
+};
+/** @internal */
+export declare const ParseMetadata$outboundSchema: z.ZodType<ParseMetadata$Outbound, z.ZodTypeDef, ParseMetadata>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseMetadata$ {
+    /** @deprecated use `ParseMetadata$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ParseMetadata, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ParseMetadata$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ParseMetadata$Outbound, z.ZodTypeDef, ParseMetadata>;
+    /** @deprecated use `ParseMetadata$Outbound` instead. */
+    type Outbound = ParseMetadata$Outbound;
+}
+export declare function parseMetadataToJSON(parseMetadata: ParseMetadata): string;
+export declare function parseMetadataFromJSON(jsonString: string): SafeParseResult<ParseMetadata, SDKValidationError>;
+/** @internal */
+export declare const Chunks$inboundSchema: z.ZodType<Chunks, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Chunks$Outbound = {
+    text: string;
+    index: number;
+    metadata?: ParseMetadata$Outbound | undefined;
+};
+/** @internal */
+export declare const Chunks$outboundSchema: z.ZodType<Chunks$Outbound, z.ZodTypeDef, Chunks>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace Chunks$ {
+    /** @deprecated use `Chunks$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<Chunks, z.ZodTypeDef, unknown>;
+    /** @deprecated use `Chunks$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<Chunks$Outbound, z.ZodTypeDef, Chunks>;
+    /** @deprecated use `Chunks$Outbound` instead. */
+    type Outbound = Chunks$Outbound;
+}
+export declare function chunksToJSON(chunks: Chunks): string;
+export declare function chunksFromJSON(jsonString: string): SafeParseResult<Chunks, SDKValidationError>;
+/** @internal */
+export declare const ParseResponseBody$inboundSchema: z.ZodType<ParseResponseBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ParseResponseBody$Outbound = {
+    chunks: Array<Chunks$Outbound>;
+};
+/** @internal */
+export declare const ParseResponseBody$outboundSchema: z.ZodType<ParseResponseBody$Outbound, z.ZodTypeDef, ParseResponseBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ParseResponseBody$ {
+    /** @deprecated use `ParseResponseBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ParseResponseBody, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ParseResponseBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ParseResponseBody$Outbound, z.ZodTypeDef, ParseResponseBody>;
+    /** @deprecated use `ParseResponseBody$Outbound` instead. */
+    type Outbound = ParseResponseBody$Outbound;
+}
+export declare function parseResponseBodyToJSON(parseResponseBody: ParseResponseBody): string;
+export declare function parseResponseBodyFromJSON(jsonString: string): SafeParseResult<ParseResponseBody, SDKValidationError>;
+//# sourceMappingURL=parse.d.ts.map