@orq-ai/node 3.8.9 → 3.9.0-rc.0

package/models/operations/chunktext.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 ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType = ClosedEnum<typeof ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType>;
+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?: ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType | 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 ChunkTextChunkingRequestKnowledgeRequestReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ChunkTextChunkingRequestKnowledgeRequestReturnType = ClosedEnum<typeof ChunkTextChunkingRequestKnowledgeRequestReturnType>;
+export declare const SDPMChunker: {
+    readonly Sdpm: "sdpm";
+};
+export type SDPMChunker = ClosedEnum<typeof SDPMChunker>;
+export declare const ChunkTextThreshold2: {
+    readonly Auto: "auto";
+};
+export type ChunkTextThreshold2 = ClosedEnum<typeof ChunkTextThreshold2>;
+/**
+ * Similarity threshold for grouping (0-1) or "auto" for automatic detection
+ */
+export type ChunkingRequestThreshold = number | ChunkTextThreshold2;
+/**
+ * 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?: ChunkTextChunkingRequestKnowledgeRequestReturnType | 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 | ChunkTextThreshold2 | 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 ChunkTextChunkingRequestKnowledgeReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ChunkTextChunkingRequestKnowledgeReturnType = ClosedEnum<typeof ChunkTextChunkingRequestKnowledgeReturnType>;
+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?: ChunkTextChunkingRequestKnowledgeReturnType | 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 ChunkTextChunkingRequestReturnType: {
+    readonly Chunks: "chunks";
+    readonly Texts: "texts";
+};
+/**
+ * Return format: chunks (with metadata) or texts (plain strings)
+ */
+export type ChunkTextChunkingRequestReturnType = ClosedEnum<typeof ChunkTextChunkingRequestReturnType>;
+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?: ChunkTextChunkingRequestReturnType | 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 ChunkTextChunkingRequest = SemanticChunkerStrategy | SDPMChunkerStrategy | AgenticChunkerStrategy | TokenChunkerStrategy | SentenceChunkerStrategy | RecursiveChunkerStrategy;
+export type ChunkTextMetadata = {
+    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?: ChunkTextMetadata | undefined;
+};
+/**
+ * Text successfully chunked
+ */
+export type ChunkTextResponseBody = {
+    chunks: Array<Chunks>;
+};
+/** @internal */
+export declare const ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType$inboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType>;
+/** @internal */
+export declare const ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType$outboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType$ {
+    /** @deprecated use `ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ChunkTextChunkingRequestKnowledgeRequestRequestBodyReturnType$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 ChunkTextChunkingRequestKnowledgeRequestReturnType$inboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestKnowledgeRequestReturnType>;
+/** @internal */
+export declare const ChunkTextChunkingRequestKnowledgeRequestReturnType$outboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestKnowledgeRequestReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextChunkingRequestKnowledgeRequestReturnType$ {
+    /** @deprecated use `ChunkTextChunkingRequestKnowledgeRequestReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ChunkTextChunkingRequestKnowledgeRequestReturnType$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 ChunkTextThreshold2$inboundSchema: z.ZodNativeEnum<typeof ChunkTextThreshold2>;
+/** @internal */
+export declare const ChunkTextThreshold2$outboundSchema: z.ZodNativeEnum<typeof ChunkTextThreshold2>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextThreshold2$ {
+    /** @deprecated use `ChunkTextThreshold2$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Auto: "auto";
+    }>;
+    /** @deprecated use `ChunkTextThreshold2$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 ChunkTextChunkingRequestKnowledgeReturnType$inboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestKnowledgeReturnType>;
+/** @internal */
+export declare const ChunkTextChunkingRequestKnowledgeReturnType$outboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestKnowledgeReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextChunkingRequestKnowledgeReturnType$ {
+    /** @deprecated use `ChunkTextChunkingRequestKnowledgeReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ChunkTextChunkingRequestKnowledgeReturnType$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 ChunkTextChunkingRequestReturnType$inboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestReturnType>;
+/** @internal */
+export declare const ChunkTextChunkingRequestReturnType$outboundSchema: z.ZodNativeEnum<typeof ChunkTextChunkingRequestReturnType>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextChunkingRequestReturnType$ {
+    /** @deprecated use `ChunkTextChunkingRequestReturnType$inboundSchema` instead. */
+    const inboundSchema: z.ZodNativeEnum<{
+        readonly Chunks: "chunks";
+        readonly Texts: "texts";
+    }>;
+    /** @deprecated use `ChunkTextChunkingRequestReturnType$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 ChunkTextChunkingRequest$inboundSchema: z.ZodType<ChunkTextChunkingRequest, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ChunkTextChunkingRequest$Outbound = SemanticChunkerStrategy$Outbound | SDPMChunkerStrategy$Outbound | AgenticChunkerStrategy$Outbound | TokenChunkerStrategy$Outbound | SentenceChunkerStrategy$Outbound | RecursiveChunkerStrategy$Outbound;
+/** @internal */
+export declare const ChunkTextChunkingRequest$outboundSchema: z.ZodType<ChunkTextChunkingRequest$Outbound, z.ZodTypeDef, ChunkTextChunkingRequest>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextChunkingRequest$ {
+    /** @deprecated use `ChunkTextChunkingRequest$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChunkTextChunkingRequest, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ChunkTextChunkingRequest$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChunkTextChunkingRequest$Outbound, z.ZodTypeDef, ChunkTextChunkingRequest>;
+    /** @deprecated use `ChunkTextChunkingRequest$Outbound` instead. */
+    type Outbound = ChunkTextChunkingRequest$Outbound;
+}
+export declare function chunkTextChunkingRequestToJSON(chunkTextChunkingRequest: ChunkTextChunkingRequest): string;
+export declare function chunkTextChunkingRequestFromJSON(jsonString: string): SafeParseResult<ChunkTextChunkingRequest, SDKValidationError>;
+/** @internal */
+export declare const ChunkTextMetadata$inboundSchema: z.ZodType<ChunkTextMetadata, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ChunkTextMetadata$Outbound = {
+    start_index: number | null;
+    end_index: number | null;
+    token_count: number | null;
+};
+/** @internal */
+export declare const ChunkTextMetadata$outboundSchema: z.ZodType<ChunkTextMetadata$Outbound, z.ZodTypeDef, ChunkTextMetadata>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextMetadata$ {
+    /** @deprecated use `ChunkTextMetadata$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChunkTextMetadata, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ChunkTextMetadata$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChunkTextMetadata$Outbound, z.ZodTypeDef, ChunkTextMetadata>;
+    /** @deprecated use `ChunkTextMetadata$Outbound` instead. */
+    type Outbound = ChunkTextMetadata$Outbound;
+}
+export declare function chunkTextMetadataToJSON(chunkTextMetadata: ChunkTextMetadata): string;
+export declare function chunkTextMetadataFromJSON(jsonString: string): SafeParseResult<ChunkTextMetadata, SDKValidationError>;
+/** @internal */
+export declare const Chunks$inboundSchema: z.ZodType<Chunks, z.ZodTypeDef, unknown>;
+/** @internal */
+export type Chunks$Outbound = {
+    text: string;
+    index: number;
+    metadata?: ChunkTextMetadata$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 ChunkTextResponseBody$inboundSchema: z.ZodType<ChunkTextResponseBody, z.ZodTypeDef, unknown>;
+/** @internal */
+export type ChunkTextResponseBody$Outbound = {
+    chunks: Array<Chunks$Outbound>;
+};
+/** @internal */
+export declare const ChunkTextResponseBody$outboundSchema: z.ZodType<ChunkTextResponseBody$Outbound, z.ZodTypeDef, ChunkTextResponseBody>;
+/**
+ * @internal
+ * @deprecated This namespace will be removed in future versions. Use schemas and types that are exported directly from this module.
+ */
+export declare namespace ChunkTextResponseBody$ {
+    /** @deprecated use `ChunkTextResponseBody$inboundSchema` instead. */
+    const inboundSchema: z.ZodType<ChunkTextResponseBody, z.ZodTypeDef, unknown>;
+    /** @deprecated use `ChunkTextResponseBody$outboundSchema` instead. */
+    const outboundSchema: z.ZodType<ChunkTextResponseBody$Outbound, z.ZodTypeDef, ChunkTextResponseBody>;
+    /** @deprecated use `ChunkTextResponseBody$Outbound` instead. */
+    type Outbound = ChunkTextResponseBody$Outbound;
+}
+export declare function chunkTextResponseBodyToJSON(chunkTextResponseBody: ChunkTextResponseBody): string;
+export declare function chunkTextResponseBodyFromJSON(jsonString: string): SafeParseResult<ChunkTextResponseBody, SDKValidationError>;
+//# sourceMappingURL=chunktext.d.ts.map