/*
 * 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 { Result as SafeParseResult } from "../../types/fp.js";
import { SDKValidationError } from "../errors/sdkvalidationerror.js";

export type Static = {
  /**
   * The number of tokens that overlap between chunks. The default value is 400. Must not exceed half of max_chunk_size_tokens.
   */
  chunkOverlapTokens: number;
  /**
   * The maximum number of tokens in each chunk. The default value is 800. The minimum value is 100 and the maximum value is 4096.
   */
  maxChunkSizeTokens: number;
};

/**
 * Customize your own chunking strategy by setting chunk size and chunk overlap.
 */
export type StaticChunkingStrategy = {
  /**
   * Always 'static'.
   */
  type: "static";
  static: Static;
};

/** @internal */
export const Static$inboundSchema: z.ZodType<Static, z.ZodTypeDef, unknown> = z
  .object({
    chunk_overlap_tokens: z.number().int(),
    max_chunk_size_tokens: z.number().int(),
  }).transform((v) => {
    return remap$(v, {
      "chunk_overlap_tokens": "chunkOverlapTokens",
      "max_chunk_size_tokens": "maxChunkSizeTokens",
    });
  });
/** @internal */
export type Static$Outbound = {
  chunk_overlap_tokens: number;
  max_chunk_size_tokens: number;
};

/** @internal */
export const Static$outboundSchema: z.ZodType<
  Static$Outbound,
  z.ZodTypeDef,
  Static
> = z.object({
  chunkOverlapTokens: z.number().int(),
  maxChunkSizeTokens: z.number().int(),
}).transform((v) => {
  return remap$(v, {
    chunkOverlapTokens: "chunk_overlap_tokens",
    maxChunkSizeTokens: "max_chunk_size_tokens",
  });
});

export function staticToJSON(value: Static): string {
  return JSON.stringify(Static$outboundSchema.parse(value));
}
export function staticFromJSON(
  jsonString: string,
): SafeParseResult<Static, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => Static$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'Static' from JSON`,
  );
}

/** @internal */
export const StaticChunkingStrategy$inboundSchema: z.ZodType<
  StaticChunkingStrategy,
  z.ZodTypeDef,
  unknown
> = z.object({
  type: z.literal("static"),
  static: z.lazy(() => Static$inboundSchema),
});
/** @internal */
export type StaticChunkingStrategy$Outbound = {
  type: "static";
  static: Static$Outbound;
};

/** @internal */
export const StaticChunkingStrategy$outboundSchema: z.ZodType<
  StaticChunkingStrategy$Outbound,
  z.ZodTypeDef,
  StaticChunkingStrategy
> = z.object({
  type: z.literal("static"),
  static: z.lazy(() => Static$outboundSchema),
});

export function staticChunkingStrategyToJSON(
  staticChunkingStrategy: StaticChunkingStrategy,
): string {
  return JSON.stringify(
    StaticChunkingStrategy$outboundSchema.parse(staticChunkingStrategy),
  );
}
export function staticChunkingStrategyFromJSON(
  jsonString: string,
): SafeParseResult<StaticChunkingStrategy, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => StaticChunkingStrategy$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'StaticChunkingStrategy' from JSON`,
  );
}