@orq-ai/node 4.15.0-rc.9 → 4.16.0-rc.0

package/src/models/operations/geteval.ts

@@ -3,11 +3,767 @@
  */
 
 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";
 
 export type GetEvalRequest = {
   id: string;
 };
 
+export type GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+export const GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType = {
+  Boolean: "boolean",
+} as const;
+export type GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType =
+  ClosedEnum<
+    typeof GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType
+  >;
+
+export type BedrockGuardrail = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  outputType?:
+    | GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType
+    | undefined;
+  type: "bedrock_eval";
+  guardrailIdentifier: string;
+  guardrailVersion: string;
+  guardrailRegion?: string | undefined;
+  integrationId?: string | null | undefined;
+};
+
+export type GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+/**
+ * The type of output expected from the evaluator
+ */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType = {
+  Boolean: "boolean",
+  Categorical: "categorical",
+  Number: "number",
+  String: "string",
+} as const;
+/**
+ * The type of output expected from the evaluator
+ */
+export type GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType =
+  ClosedEnum<
+    typeof GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType
+  >;
+
+export type Typescript = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  /**
+   * The type of output expected from the evaluator
+   */
+  outputType?:
+    | GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType
+    | undefined;
+  code: string;
+  type: "typescript_eval";
+};
+
+export type GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+export const GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType = {
+  Boolean: "boolean",
+  Number: "number",
+} as const;
+export type GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType =
+  ClosedEnum<
+    typeof GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType
+  >;
+
+export type ResponseBodyPython = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  outputType?:
+    | GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType
+    | undefined;
+  code: string;
+  type: "python_eval";
+};
+
+export type GetEvalResponseBodyEvalsResponse200Metadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+/**
+ * The type of output expected from the evaluator
+ */
+export const GetEvalResponseBodyEvalsResponse200OutputType = {
+  Boolean: "boolean",
+  Categorical: "categorical",
+  Number: "number",
+  String: "string",
+} as const;
+/**
+ * The type of output expected from the evaluator
+ */
+export type GetEvalResponseBodyEvalsResponse200OutputType = ClosedEnum<
+  typeof GetEvalResponseBodyEvalsResponse200OutputType
+>;
+
+export const ResponseBodyMethod = {
+  Get: "GET",
+  Post: "POST",
+} as const;
+export type ResponseBodyMethod = ClosedEnum<typeof ResponseBodyMethod>;
+
+export type GetEvalResponseBodyHTTP = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyEvalsResponse200Metadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  /**
+   * The type of output expected from the evaluator
+   */
+  outputType?: GetEvalResponseBodyEvalsResponse200OutputType | undefined;
+  type: "http_eval";
+  url: string;
+  method: ResponseBodyMethod;
+  headers: { [k: string]: string };
+  payload: { [k: string]: any };
+};
+
+export type GetEvalResponseBodyEvalsResponseMetadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+export const GetEvalResponseBodyEvalsResponseOutputType = {
+  Boolean: "boolean",
+} as const;
+export type GetEvalResponseBodyEvalsResponseOutputType = ClosedEnum<
+  typeof GetEvalResponseBodyEvalsResponseOutputType
+>;
+
+export type Json = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyEvalsResponseMetadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  outputType?: GetEvalResponseBodyEvalsResponseOutputType | undefined;
+  type: "json_schema";
+  schema: string;
+};
+
+export type GetEvalResponseBodyEvalsMetadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+export const GetEvalResponseBodyEvalsOutputType = {
+  Number: "number",
+} as const;
+export type GetEvalResponseBodyEvalsOutputType = ClosedEnum<
+  typeof GetEvalResponseBodyEvalsOutputType
+>;
+
+export type GetEvalResponseBodyModel = {
+  id: string;
+  integrationId?: string | null | undefined;
+};
+
+export const RagasMetric = {
+  ContextPrecision: "context_precision",
+  ContextRecall: "context_recall",
+  ContextEntitiesRecall: "context_entities_recall",
+  Harmfulness: "harmfulness",
+  Maliciousness: "maliciousness",
+  Coherence: "coherence",
+  Correctness: "correctness",
+  Conciseness: "conciseness",
+  ResponseRelevancy: "response_relevancy",
+  Faithfulness: "faithfulness",
+  Summarization: "summarization",
+  NoiseSensitivity: "noise_sensitivity",
+} as const;
+export type RagasMetric = ClosedEnum<typeof RagasMetric>;
+
+export type Ragas = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyEvalsMetadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  outputType?: GetEvalResponseBodyEvalsOutputType | undefined;
+  type: "ragas";
+  model: GetEvalResponseBodyModel;
+  ragasMetric: RagasMetric;
+};
+
+export type GetEvalResponseBodyMetadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+export const GetEvalResponseBodyOutputType = {
+  Boolean: "boolean",
+  Categorical: "categorical",
+  Number: "number",
+  String: "string",
+} as const;
+export type GetEvalResponseBodyOutputType = ClosedEnum<
+  typeof GetEvalResponseBodyOutputType
+>;
+
+export type ThirtyTwo = {
+  type: "grammar_diversity";
+};
+
+export type ThirtyOne = {
+  type: "lexical_repetition";
+};
+
+export type Thirty = {
+  type: "sentences_count";
+};
+
+export type TwentyNine = {
+  type: "words_count";
+};
+
+export type TwentyEight = {
+  type: "gse_english_level";
+};
+
+export type TwentySeven = {
+  type: "flesch_reading_ease";
+};
+
+export type TwentySix = {
+  type: "most_repeated_words";
+};
+
+export type TwentyFive = {
+  type: "keywords_match";
+  keywords: Array<string>;
+};
+
+export type TwentyFour = {
+  type: "levenshtein_distance";
+};
+
+export type TwentyThree = {
+  type: "cosine_similarity";
+};
+
+export type TwentyTwo = {
+  type: "meteor_score";
+};
+
+export type TwentyOne = {
+  type: "rouge_n";
+};
+
+export type Twenty = {
+  type: "bleu_score";
+};
+
+export type Nineteen = {
+  type: "bert_score";
+};
+
+export type Eighteen = {
+  type: "moderations_google";
+};
+
+export type Seventeen = {
+  type: "moderations_openai";
+};
+
+export type Sixteen = {
+  type: "is_valid_json";
+};
+
+export type Fifteen = {
+  type: "regex";
+  pattern: string;
+};
+
+export type Fourteen = {
+  type: "one_line";
+};
+
+export type Thirteen = {
+  type: "length_greater_than";
+  value: number;
+};
+
+export type Twelve = {
+  type: "length_between";
+  min: number;
+  max: number;
+};
+
+export type Eleven = {
+  type: "length_less_than";
+  value: number;
+};
+
+export type Ten = {
+  type: "exact_match";
+};
+
+export type Nine = {
+  type: "ends_with";
+  value: string;
+};
+
+export type Eight = {
+  type: "start_with";
+  value: string;
+};
+
+export type Seven = {
+  type: "contains_valid_link";
+};
+
+export type FunctionParams6 = {
+  type: "contains_url";
+};
+
+export type FunctionParams5 = {
+  type: "contains_email";
+};
+
+export type FunctionParams4 = {
+  type: "contains_any";
+  keywords: Array<string>;
+};
+
+export type FunctionParams3 = {
+  type: "contains_all";
+  keywords: Array<string>;
+};
+
+export type FunctionParams2 = {
+  type: "contains_none";
+  keywords: Array<string>;
+};
+
+export type FunctionParams1 = {
+  type: "contains";
+  value: string;
+};
+
+export type FunctionParams =
+  | FunctionParams1
+  | FunctionParams2
+  | FunctionParams3
+  | FunctionParams4
+  | FunctionParams5
+  | FunctionParams6
+  | Seven
+  | Eight
+  | Nine
+  | Ten
+  | Eleven
+  | Twelve
+  | Thirteen
+  | Fourteen
+  | Fifteen
+  | Sixteen
+  | Seventeen
+  | Eighteen
+  | Nineteen
+  | Twenty
+  | TwentyOne
+  | TwentyTwo
+  | TwentyThree
+  | TwentyFour
+  | TwentyFive
+  | TwentySix
+  | TwentySeven
+  | TwentyEight
+  | TwentyNine
+  | Thirty
+  | ThirtyOne
+  | ThirtyTwo;
+
+export type GetEvalResponseBodyFunction = {
+  enabled: boolean;
+  metadata: GetEvalResponseBodyMetadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  outputType: GetEvalResponseBodyOutputType;
+  type: "function_eval";
+  functionParams:
+    | FunctionParams1
+    | FunctionParams2
+    | FunctionParams3
+    | FunctionParams4
+    | FunctionParams5
+    | FunctionParams6
+    | Seven
+    | Eight
+    | Nine
+    | Ten
+    | Eleven
+    | Twelve
+    | Thirteen
+    | Fourteen
+    | Fifteen
+    | Sixteen
+    | Seventeen
+    | Eighteen
+    | Nineteen
+    | Twenty
+    | TwentyOne
+    | TwentyTwo
+    | TwentyThree
+    | TwentyFour
+    | TwentyFive
+    | TwentySix
+    | TwentySeven
+    | TwentyEight
+    | TwentyNine
+    | Thirty
+    | ThirtyOne
+    | ThirtyTwo;
+};
+
+export type ResponseBodyMetadata = {
+  requiredModelWithToolsSupport?: boolean | undefined;
+  requiredRetrievalContext?: boolean | undefined;
+  requiredExpectedOutput?: boolean | undefined;
+  supportedOnInputType?: boolean | undefined;
+  supportedOnOutputType?: boolean | undefined;
+  supportUseAsGuardrail?: boolean | undefined;
+};
+
+/**
+ * The type of output expected from the evaluator
+ */
+export const ResponseBodyOutputType = {
+  Boolean: "boolean",
+  Categorical: "categorical",
+  Number: "number",
+  String: "string",
+} as const;
+/**
+ * The type of output expected from the evaluator
+ */
+export type ResponseBodyOutputType = ClosedEnum<typeof ResponseBodyOutputType>;
+
+export const ResponseBodyMode = {
+  Single: "single",
+  Jury: "jury",
+} as const;
+export type ResponseBodyMode = ClosedEnum<typeof ResponseBodyMode>;
+
+export type ResponseBodyModelParameters = {
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  topK?: number | undefined;
+  topP?: number | undefined;
+  frequencyPenalty?: number | undefined;
+  presencePenalty?: number | undefined;
+  reasoningEffort?: string | undefined;
+  budgetTokens?: number | undefined;
+};
+
+export type ResponseBodyModel = {
+  id: string;
+  integrationId?: string | null | undefined;
+  modelParameters?: ResponseBodyModelParameters | undefined;
+};
+
+export type GetEvalResponseBodyModelParameters = {
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  topK?: number | undefined;
+  topP?: number | undefined;
+  frequencyPenalty?: number | undefined;
+  presencePenalty?: number | undefined;
+  reasoningEffort?: string | undefined;
+  budgetTokens?: number | undefined;
+};
+
+export type GetEvalResponseBodyEvalsResponseModel = {
+  id: string;
+  integrationId?: string | null | undefined;
+  modelParameters?: GetEvalResponseBodyModelParameters | undefined;
+};
+
+export type ResponseBodyRetry = {
+  count: number;
+  onCodes?: Array<number> | undefined;
+};
+
+export type GetEvalResponseBodyEvalsResponseModelParameters = {
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  topK?: number | undefined;
+  topP?: number | undefined;
+  frequencyPenalty?: number | undefined;
+  presencePenalty?: number | undefined;
+  reasoningEffort?: string | undefined;
+  budgetTokens?: number | undefined;
+};
+
+export type GetEvalResponseBodyEvalsResponse200ApplicationJSONModel = {
+  id: string;
+  integrationId?: string | null | undefined;
+  modelParameters?: GetEvalResponseBodyEvalsResponseModelParameters | undefined;
+};
+
+export type ResponseBodyFallbacks = {
+  model: GetEvalResponseBodyEvalsResponse200ApplicationJSONModel;
+};
+
+export type ResponseBodyJudges = {
+  model: GetEvalResponseBodyEvalsResponseModel;
+  retry?: ResponseBodyRetry | undefined;
+  fallbacks?: Array<ResponseBodyFallbacks> | undefined;
+};
+
+export type GetEvalResponseBodyEvalsModelParameters = {
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  topK?: number | undefined;
+  topP?: number | undefined;
+  frequencyPenalty?: number | undefined;
+  presencePenalty?: number | undefined;
+  reasoningEffort?: string | undefined;
+  budgetTokens?: number | undefined;
+};
+
+export type GetEvalResponseBodyEvalsModel = {
+  id: string;
+  integrationId?: string | null | undefined;
+  modelParameters?: GetEvalResponseBodyEvalsModelParameters | undefined;
+};
+
+export type GetEvalResponseBodyRetry = {
+  count: number;
+  onCodes?: Array<number> | undefined;
+};
+
+export type GetEvalResponseBodyEvalsResponse200ModelParameters = {
+  temperature?: number | undefined;
+  maxTokens?: number | undefined;
+  topK?: number | undefined;
+  topP?: number | undefined;
+  frequencyPenalty?: number | undefined;
+  presencePenalty?: number | undefined;
+  reasoningEffort?: string | undefined;
+  budgetTokens?: number | undefined;
+};
+
+export type GetEvalResponseBodyEvalsResponse200Model = {
+  id: string;
+  integrationId?: string | null | undefined;
+  modelParameters?:
+    | GetEvalResponseBodyEvalsResponse200ModelParameters
+    | undefined;
+};
+
+export type GetEvalResponseBodyFallbacks = {
+  model: GetEvalResponseBodyEvalsResponse200Model;
+};
+
+export type ResponseBodyReplacementJudges = {
+  model: GetEvalResponseBodyEvalsModel;
+  retry?: GetEvalResponseBodyRetry | undefined;
+  fallbacks?: Array<GetEvalResponseBodyFallbacks> | undefined;
+};
+
+export const ResponseBodyTieValue = {
+  Tie: "Tie",
+} as const;
+export type ResponseBodyTieValue = ClosedEnum<typeof ResponseBodyTieValue>;
+
+export type ResponseBodyJury = {
+  judges: Array<ResponseBodyJudges>;
+  replacementJudges?: Array<ResponseBodyReplacementJudges> | undefined;
+  minSuccessfulJudges: number;
+  tieValue: ResponseBodyTieValue;
+};
+
+export type ResponseBodyCategoricalLabels = {
+  value: string;
+  description?: string | undefined;
+};
+
+export type ResponseBodyLLM = {
+  enabled: boolean;
+  metadata: ResponseBodyMetadata;
+  id: string;
+  displayName: string;
+  description: string;
+  owner: string;
+  created: string;
+  updated: string;
+  createdById?: string | null | undefined;
+  updatedById?: string | null | undefined;
+  domainId: string;
+  /**
+   * Unique identifier of the project owning this evaluator.
+   */
+  projectId?: string | undefined;
+  guardrailConfig?: any | undefined;
+  /**
+   * The type of output expected from the evaluator
+   */
+  outputType?: ResponseBodyOutputType | undefined;
+  type: "llm_eval";
+  mode?: ResponseBodyMode | null | undefined;
+  repetitions?: number | null | undefined;
+  model?: ResponseBodyModel | undefined;
+  jury?: ResponseBodyJury | null | undefined;
+  prompt: string;
+  categories?: Array<string> | null | undefined;
+  categoricalLabels?: Array<ResponseBodyCategoricalLabels> | null | undefined;
+  datasetId?: string | null | undefined;
+};
+
+/**
+ * The evaluator. The response shape depends on the evaluator `type`.
+ */
+export type GetEvalResponseBody =
+  | ResponseBodyLLM
+  | GetEvalResponseBodyFunction
+  | Ragas
+  | Json
+  | GetEvalResponseBodyHTTP
+  | ResponseBodyPython
+  | Typescript
+  | BedrockGuardrail;
+
 /** @internal */
 export type GetEvalRequest$Outbound = {
   id: string;
@@ -25,3 +781,2020 @@ export const GetEvalRequest$outboundSchema: z.ZodType<
 export function getEvalRequestToJSON(getEvalRequest: GetEvalRequest): string {
   return JSON.stringify(GetEvalRequest$outboundSchema.parse(getEvalRequest));
 }
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    required_model_with_tools_support: z.boolean().optional(),
+    required_retrieval_context: z.boolean().optional(),
+    required_expected_output: z.boolean().optional(),
+    supported_on_input_type: z.boolean().optional(),
+    supported_on_output_type: z.boolean().optional(),
+    support_use_as_guardrail: z.boolean().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "required_model_with_tools_support": "requiredModelWithToolsSupport",
+      "required_retrieval_context": "requiredRetrievalContext",
+      "required_expected_output": "requiredExpectedOutput",
+      "supported_on_input_type": "supportedOnInputType",
+      "supported_on_output_type": "supportedOnOutputType",
+      "support_use_as_guardrail": "supportUseAsGuardrail",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponse200ApplicationJSON8MetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType
+  > = z.nativeEnum(
+    GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType,
+  );
+
+/** @internal */
+export const BedrockGuardrail$inboundSchema: z.ZodType<
+  BedrockGuardrail,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  metadata: z.lazy(() =>
+    GetEvalResponseBodyEvalsResponse200ApplicationJson8Metadata$inboundSchema
+  ),
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  owner: z.string(),
+  created: z.string().default("2026-08-05T15:12:51.947Z"),
+  updated: z.string().default("2026-08-05T15:12:51.947Z"),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  domain_id: z.string(),
+  project_id: z.string().optional(),
+  guardrail_config: z.any().optional(),
+  output_type:
+    GetEvalResponseBodyEvalsResponse200ApplicationJson8OutputType$inboundSchema
+      .optional(),
+  type: z.literal("bedrock_eval"),
+  guardrail_identifier: z.string(),
+  guardrail_version: z.string().default("DRAFT"),
+  guardrail_region: z.string().optional(),
+  integration_id: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "domain_id": "domainId",
+    "project_id": "projectId",
+    "guardrail_config": "guardrailConfig",
+    "output_type": "outputType",
+    "guardrail_identifier": "guardrailIdentifier",
+    "guardrail_version": "guardrailVersion",
+    "guardrail_region": "guardrailRegion",
+    "integration_id": "integrationId",
+  });
+});
+
+export function bedrockGuardrailFromJSON(
+  jsonString: string,
+): SafeParseResult<BedrockGuardrail, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => BedrockGuardrail$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'BedrockGuardrail' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    required_model_with_tools_support: z.boolean().optional(),
+    required_retrieval_context: z.boolean().optional(),
+    required_expected_output: z.boolean().optional(),
+    supported_on_input_type: z.boolean().optional(),
+    supported_on_output_type: z.boolean().optional(),
+    support_use_as_guardrail: z.boolean().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "required_model_with_tools_support": "requiredModelWithToolsSupport",
+      "required_retrieval_context": "requiredRetrievalContext",
+      "required_expected_output": "requiredExpectedOutput",
+      "supported_on_input_type": "supportedOnInputType",
+      "supported_on_output_type": "supportedOnOutputType",
+      "support_use_as_guardrail": "supportUseAsGuardrail",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponse200ApplicationJSON7MetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType
+  > = z.nativeEnum(
+    GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType,
+  );
+
+/** @internal */
+export const Typescript$inboundSchema: z.ZodType<
+  Typescript,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  metadata: z.lazy(() =>
+    GetEvalResponseBodyEvalsResponse200ApplicationJson7Metadata$inboundSchema
+  ),
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  owner: z.string(),
+  created: z.string().default("2026-08-05T15:12:51.947Z"),
+  updated: z.string().default("2026-08-05T15:12:51.947Z"),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  domain_id: z.string(),
+  project_id: z.string().optional(),
+  guardrail_config: z.any().optional(),
+  output_type:
+    GetEvalResponseBodyEvalsResponse200ApplicationJson7OutputType$inboundSchema
+      .optional(),
+  code: z.string(),
+  type: z.literal("typescript_eval"),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "domain_id": "domainId",
+    "project_id": "projectId",
+    "guardrail_config": "guardrailConfig",
+    "output_type": "outputType",
+  });
+});
+
+export function typescriptFromJSON(
+  jsonString: string,
+): SafeParseResult<Typescript, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Typescript$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Typescript' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    required_model_with_tools_support: z.boolean().optional(),
+    required_retrieval_context: z.boolean().optional(),
+    required_expected_output: z.boolean().optional(),
+    supported_on_input_type: z.boolean().optional(),
+    supported_on_output_type: z.boolean().optional(),
+    support_use_as_guardrail: z.boolean().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "required_model_with_tools_support": "requiredModelWithToolsSupport",
+      "required_retrieval_context": "requiredRetrievalContext",
+      "required_expected_output": "requiredExpectedOutput",
+      "supported_on_input_type": "supportedOnInputType",
+      "supported_on_output_type": "supportedOnOutputType",
+      "support_use_as_guardrail": "supportUseAsGuardrail",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponse200ApplicationJSONMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType$inboundSchema:
+  z.ZodNativeEnum<
+    typeof GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType
+  > = z.nativeEnum(
+    GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType,
+  );
+
+/** @internal */
+export const ResponseBodyPython$inboundSchema: z.ZodType<
+  ResponseBodyPython,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  metadata: z.lazy(() =>
+    GetEvalResponseBodyEvalsResponse200ApplicationJSONMetadata$inboundSchema
+  ),
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  owner: z.string(),
+  created: z.string().default("2026-08-05T15:12:51.947Z"),
+  updated: z.string().default("2026-08-05T15:12:51.947Z"),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  domain_id: z.string(),
+  project_id: z.string().optional(),
+  guardrail_config: z.any().optional(),
+  output_type:
+    GetEvalResponseBodyEvalsResponse200ApplicationJSONOutputType$inboundSchema
+      .optional(),
+  code: z.string(),
+  type: z.literal("python_eval"),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "domain_id": "domainId",
+    "project_id": "projectId",
+    "guardrail_config": "guardrailConfig",
+    "output_type": "outputType",
+  });
+});
+
+export function responseBodyPythonFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyPython, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyPython$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyPython' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200Metadata$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponse200Metadata,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    required_model_with_tools_support: z.boolean().optional(),
+    required_retrieval_context: z.boolean().optional(),
+    required_expected_output: z.boolean().optional(),
+    supported_on_input_type: z.boolean().optional(),
+    supported_on_output_type: z.boolean().optional(),
+    support_use_as_guardrail: z.boolean().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "required_model_with_tools_support": "requiredModelWithToolsSupport",
+      "required_retrieval_context": "requiredRetrievalContext",
+      "required_expected_output": "requiredExpectedOutput",
+      "supported_on_input_type": "supportedOnInputType",
+      "supported_on_output_type": "supportedOnOutputType",
+      "support_use_as_guardrail": "supportUseAsGuardrail",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponse200MetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200Metadata,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200Metadata$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200Metadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200OutputType$inboundSchema:
+  z.ZodNativeEnum<typeof GetEvalResponseBodyEvalsResponse200OutputType> = z
+    .nativeEnum(GetEvalResponseBodyEvalsResponse200OutputType);
+
+/** @internal */
+export const ResponseBodyMethod$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseBodyMethod
+> = z.nativeEnum(ResponseBodyMethod);
+
+/** @internal */
+export const GetEvalResponseBodyHTTP$inboundSchema: z.ZodType<
+  GetEvalResponseBodyHTTP,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  metadata: z.lazy(() =>
+    GetEvalResponseBodyEvalsResponse200Metadata$inboundSchema
+  ),
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  owner: z.string(),
+  created: z.string().default("2026-08-05T15:12:51.947Z"),
+  updated: z.string().default("2026-08-05T15:12:51.947Z"),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  domain_id: z.string(),
+  project_id: z.string().optional(),
+  guardrail_config: z.any().optional(),
+  output_type: GetEvalResponseBodyEvalsResponse200OutputType$inboundSchema
+    .optional(),
+  type: z.literal("http_eval"),
+  url: z.string(),
+  method: ResponseBodyMethod$inboundSchema,
+  headers: z.record(z.string()),
+  payload: z.record(z.any()),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "domain_id": "domainId",
+    "project_id": "projectId",
+    "guardrail_config": "guardrailConfig",
+    "output_type": "outputType",
+  });
+});
+
+export function getEvalResponseBodyHTTPFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyHTTP, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyHTTP$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyHTTP' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponseMetadata$inboundSchema: z.ZodType<
+  GetEvalResponseBodyEvalsResponseMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  required_model_with_tools_support: z.boolean().optional(),
+  required_retrieval_context: z.boolean().optional(),
+  required_expected_output: z.boolean().optional(),
+  supported_on_input_type: z.boolean().optional(),
+  supported_on_output_type: z.boolean().optional(),
+  support_use_as_guardrail: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "required_model_with_tools_support": "requiredModelWithToolsSupport",
+    "required_retrieval_context": "requiredRetrievalContext",
+    "required_expected_output": "requiredExpectedOutput",
+    "supported_on_input_type": "supportedOnInputType",
+    "supported_on_output_type": "supportedOnOutputType",
+    "support_use_as_guardrail": "supportUseAsGuardrail",
+  });
+});
+
+export function getEvalResponseBodyEvalsResponseMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponseMetadata,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponseMetadata$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponseMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponseOutputType$inboundSchema:
+  z.ZodNativeEnum<typeof GetEvalResponseBodyEvalsResponseOutputType> = z
+    .nativeEnum(GetEvalResponseBodyEvalsResponseOutputType);
+
+/** @internal */
+export const Json$inboundSchema: z.ZodType<Json, z.ZodTypeDef, unknown> = z
+  .object({
+    enabled: z.boolean().default(true),
+    metadata: z.lazy(() =>
+      GetEvalResponseBodyEvalsResponseMetadata$inboundSchema
+    ),
+    _id: z.string(),
+    display_name: z.string(),
+    description: z.string(),
+    owner: z.string(),
+    created: z.string().default("2026-08-05T15:12:51.947Z"),
+    updated: z.string().default("2026-08-05T15:12:51.947Z"),
+    created_by_id: z.nullable(z.string()).optional(),
+    updated_by_id: z.nullable(z.string()).optional(),
+    domain_id: z.string(),
+    project_id: z.string().optional(),
+    guardrail_config: z.any().optional(),
+    output_type: GetEvalResponseBodyEvalsResponseOutputType$inboundSchema
+      .optional(),
+    type: z.literal("json_schema"),
+    schema: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      "_id": "id",
+      "display_name": "displayName",
+      "created_by_id": "createdById",
+      "updated_by_id": "updatedById",
+      "domain_id": "domainId",
+      "project_id": "projectId",
+      "guardrail_config": "guardrailConfig",
+      "output_type": "outputType",
+    });
+  });
+
+export function jsonFromJSON(
+  jsonString: string,
+): SafeParseResult<Json, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Json$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Json' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsMetadata$inboundSchema: z.ZodType<
+  GetEvalResponseBodyEvalsMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  required_model_with_tools_support: z.boolean().optional(),
+  required_retrieval_context: z.boolean().optional(),
+  required_expected_output: z.boolean().optional(),
+  supported_on_input_type: z.boolean().optional(),
+  supported_on_output_type: z.boolean().optional(),
+  support_use_as_guardrail: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "required_model_with_tools_support": "requiredModelWithToolsSupport",
+    "required_retrieval_context": "requiredRetrievalContext",
+    "required_expected_output": "requiredExpectedOutput",
+    "supported_on_input_type": "supportedOnInputType",
+    "supported_on_output_type": "supportedOnOutputType",
+    "support_use_as_guardrail": "supportUseAsGuardrail",
+  });
+});
+
+export function getEvalResponseBodyEvalsMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyEvalsMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyEvalsMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsOutputType$inboundSchema: z.ZodNativeEnum<
+  typeof GetEvalResponseBodyEvalsOutputType
+> = z.nativeEnum(GetEvalResponseBodyEvalsOutputType);
+
+/** @internal */
+export const GetEvalResponseBodyModel$inboundSchema: z.ZodType<
+  GetEvalResponseBodyModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  integration_id: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "integration_id": "integrationId",
+  });
+});
+
+export function getEvalResponseBodyModelFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyModel' from JSON`,
+  );
+}
+
+/** @internal */
+export const RagasMetric$inboundSchema: z.ZodNativeEnum<typeof RagasMetric> = z
+  .nativeEnum(RagasMetric);
+
+/** @internal */
+export const Ragas$inboundSchema: z.ZodType<Ragas, z.ZodTypeDef, unknown> = z
+  .object({
+    enabled: z.boolean().default(true),
+    metadata: z.lazy(() => GetEvalResponseBodyEvalsMetadata$inboundSchema),
+    _id: z.string(),
+    display_name: z.string(),
+    description: z.string(),
+    owner: z.string(),
+    created: z.string().default("2026-08-05T15:12:51.947Z"),
+    updated: z.string().default("2026-08-05T15:12:51.947Z"),
+    created_by_id: z.nullable(z.string()).optional(),
+    updated_by_id: z.nullable(z.string()).optional(),
+    domain_id: z.string(),
+    project_id: z.string().optional(),
+    guardrail_config: z.any().optional(),
+    output_type: GetEvalResponseBodyEvalsOutputType$inboundSchema.optional(),
+    type: z.literal("ragas"),
+    model: z.lazy(() => GetEvalResponseBodyModel$inboundSchema),
+    ragas_metric: RagasMetric$inboundSchema,
+  }).transform((v) => {
+    return remap$(v, {
+      "_id": "id",
+      "display_name": "displayName",
+      "created_by_id": "createdById",
+      "updated_by_id": "updatedById",
+      "domain_id": "domainId",
+      "project_id": "projectId",
+      "guardrail_config": "guardrailConfig",
+      "output_type": "outputType",
+      "ragas_metric": "ragasMetric",
+    });
+  });
+
+export function ragasFromJSON(
+  jsonString: string,
+): SafeParseResult<Ragas, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ragas$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ragas' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyMetadata$inboundSchema: z.ZodType<
+  GetEvalResponseBodyMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  required_model_with_tools_support: z.boolean().optional(),
+  required_retrieval_context: z.boolean().optional(),
+  required_expected_output: z.boolean().optional(),
+  supported_on_input_type: z.boolean().optional(),
+  supported_on_output_type: z.boolean().optional(),
+  support_use_as_guardrail: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "required_model_with_tools_support": "requiredModelWithToolsSupport",
+    "required_retrieval_context": "requiredRetrievalContext",
+    "required_expected_output": "requiredExpectedOutput",
+    "supported_on_input_type": "supportedOnInputType",
+    "supported_on_output_type": "supportedOnOutputType",
+    "support_use_as_guardrail": "supportUseAsGuardrail",
+  });
+});
+
+export function getEvalResponseBodyMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyOutputType$inboundSchema: z.ZodNativeEnum<
+  typeof GetEvalResponseBodyOutputType
+> = z.nativeEnum(GetEvalResponseBodyOutputType);
+
+/** @internal */
+export const ThirtyTwo$inboundSchema: z.ZodType<
+  ThirtyTwo,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("grammar_diversity"),
+});
+
+export function thirtyTwoFromJSON(
+  jsonString: string,
+): SafeParseResult<ThirtyTwo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThirtyTwo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThirtyTwo' from JSON`,
+  );
+}
+
+/** @internal */
+export const ThirtyOne$inboundSchema: z.ZodType<
+  ThirtyOne,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("lexical_repetition"),
+});
+
+export function thirtyOneFromJSON(
+  jsonString: string,
+): SafeParseResult<ThirtyOne, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ThirtyOne$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ThirtyOne' from JSON`,
+  );
+}
+
+/** @internal */
+export const Thirty$inboundSchema: z.ZodType<Thirty, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("sentences_count"),
+  });
+
+export function thirtyFromJSON(
+  jsonString: string,
+): SafeParseResult<Thirty, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Thirty$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Thirty' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyNine$inboundSchema: z.ZodType<
+  TwentyNine,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("words_count"),
+});
+
+export function twentyNineFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyNine, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyNine$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyNine' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyEight$inboundSchema: z.ZodType<
+  TwentyEight,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("gse_english_level"),
+});
+
+export function twentyEightFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyEight, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyEight$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyEight' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentySeven$inboundSchema: z.ZodType<
+  TwentySeven,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("flesch_reading_ease"),
+});
+
+export function twentySevenFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentySeven, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentySeven$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentySeven' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentySix$inboundSchema: z.ZodType<
+  TwentySix,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("most_repeated_words"),
+});
+
+export function twentySixFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentySix, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentySix$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentySix' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyFive$inboundSchema: z.ZodType<
+  TwentyFive,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("keywords_match"),
+  keywords: z.array(z.string()),
+});
+
+export function twentyFiveFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyFive, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyFive$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyFive' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyFour$inboundSchema: z.ZodType<
+  TwentyFour,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("levenshtein_distance"),
+});
+
+export function twentyFourFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyFour, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyFour$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyFour' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyThree$inboundSchema: z.ZodType<
+  TwentyThree,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("cosine_similarity"),
+});
+
+export function twentyThreeFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyThree, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyThree$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyThree' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyTwo$inboundSchema: z.ZodType<
+  TwentyTwo,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("meteor_score"),
+});
+
+export function twentyTwoFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyTwo, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyTwo$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyTwo' from JSON`,
+  );
+}
+
+/** @internal */
+export const TwentyOne$inboundSchema: z.ZodType<
+  TwentyOne,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("rouge_n"),
+});
+
+export function twentyOneFromJSON(
+  jsonString: string,
+): SafeParseResult<TwentyOne, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => TwentyOne$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'TwentyOne' from JSON`,
+  );
+}
+
+/** @internal */
+export const Twenty$inboundSchema: z.ZodType<Twenty, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("bleu_score"),
+  });
+
+export function twentyFromJSON(
+  jsonString: string,
+): SafeParseResult<Twenty, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Twenty$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Twenty' from JSON`,
+  );
+}
+
+/** @internal */
+export const Nineteen$inboundSchema: z.ZodType<
+  Nineteen,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("bert_score"),
+});
+
+export function nineteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Nineteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Nineteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Nineteen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Eighteen$inboundSchema: z.ZodType<
+  Eighteen,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("moderations_google"),
+});
+
+export function eighteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Eighteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Eighteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Eighteen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Seventeen$inboundSchema: z.ZodType<
+  Seventeen,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("moderations_openai"),
+});
+
+export function seventeenFromJSON(
+  jsonString: string,
+): SafeParseResult<Seventeen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Seventeen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Seventeen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Sixteen$inboundSchema: z.ZodType<Sixteen, z.ZodTypeDef, unknown> =
+  z.object({
+    type: z.literal("is_valid_json"),
+  });
+
+export function sixteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Sixteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Sixteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Sixteen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Fifteen$inboundSchema: z.ZodType<Fifteen, z.ZodTypeDef, unknown> =
+  z.object({
+    type: z.literal("regex"),
+    pattern: z.string(),
+  });
+
+export function fifteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Fifteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Fifteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Fifteen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Fourteen$inboundSchema: z.ZodType<
+  Fourteen,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("one_line"),
+});
+
+export function fourteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Fourteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Fourteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Fourteen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Thirteen$inboundSchema: z.ZodType<
+  Thirteen,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("length_greater_than"),
+  value: z.number(),
+});
+
+export function thirteenFromJSON(
+  jsonString: string,
+): SafeParseResult<Thirteen, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Thirteen$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Thirteen' from JSON`,
+  );
+}
+
+/** @internal */
+export const Twelve$inboundSchema: z.ZodType<Twelve, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("length_between"),
+    min: z.number(),
+    max: z.number(),
+  });
+
+export function twelveFromJSON(
+  jsonString: string,
+): SafeParseResult<Twelve, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Twelve$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Twelve' from JSON`,
+  );
+}
+
+/** @internal */
+export const Eleven$inboundSchema: z.ZodType<Eleven, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("length_less_than"),
+    value: z.number(),
+  });
+
+export function elevenFromJSON(
+  jsonString: string,
+): SafeParseResult<Eleven, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Eleven$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Eleven' from JSON`,
+  );
+}
+
+/** @internal */
+export const Ten$inboundSchema: z.ZodType<Ten, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("exact_match"),
+  });
+
+export function tenFromJSON(
+  jsonString: string,
+): SafeParseResult<Ten, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Ten$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Ten' from JSON`,
+  );
+}
+
+/** @internal */
+export const Nine$inboundSchema: z.ZodType<Nine, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("ends_with"),
+    value: z.string(),
+  });
+
+export function nineFromJSON(
+  jsonString: string,
+): SafeParseResult<Nine, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Nine$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Nine' from JSON`,
+  );
+}
+
+/** @internal */
+export const Eight$inboundSchema: z.ZodType<Eight, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("start_with"),
+    value: z.string(),
+  });
+
+export function eightFromJSON(
+  jsonString: string,
+): SafeParseResult<Eight, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Eight$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Eight' from JSON`,
+  );
+}
+
+/** @internal */
+export const Seven$inboundSchema: z.ZodType<Seven, z.ZodTypeDef, unknown> = z
+  .object({
+    type: z.literal("contains_valid_link"),
+  });
+
+export function sevenFromJSON(
+  jsonString: string,
+): SafeParseResult<Seven, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => Seven$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'Seven' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams6$inboundSchema: z.ZodType<
+  FunctionParams6,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("contains_url"),
+});
+
+export function functionParams6FromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams6, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams6$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams6' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams5$inboundSchema: z.ZodType<
+  FunctionParams5,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("contains_email"),
+});
+
+export function functionParams5FromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams5, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams5$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams5' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams4$inboundSchema: z.ZodType<
+  FunctionParams4,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("contains_any"),
+  keywords: z.array(z.string()),
+});
+
+export function functionParams4FromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams4, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams4$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams4' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams3$inboundSchema: z.ZodType<
+  FunctionParams3,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("contains_all"),
+  keywords: z.array(z.string()),
+});
+
+export function functionParams3FromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams3, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams3$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams3' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams2$inboundSchema: z.ZodType<
+  FunctionParams2,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("contains_none"),
+  keywords: z.array(z.string()),
+});
+
+export function functionParams2FromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams2, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams2$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams2' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams1$inboundSchema: z.ZodType<
+  FunctionParams1,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  type: z.literal("contains"),
+  value: z.string(),
+});
+
+export function functionParams1FromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams1, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams1$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams1' from JSON`,
+  );
+}
+
+/** @internal */
+export const FunctionParams$inboundSchema: z.ZodType<
+  FunctionParams,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => FunctionParams1$inboundSchema),
+  z.lazy(() => FunctionParams2$inboundSchema),
+  z.lazy(() => FunctionParams3$inboundSchema),
+  z.lazy(() => FunctionParams4$inboundSchema),
+  z.lazy(() => FunctionParams5$inboundSchema),
+  z.lazy(() => FunctionParams6$inboundSchema),
+  z.lazy(() => Seven$inboundSchema),
+  z.lazy(() => Eight$inboundSchema),
+  z.lazy(() => Nine$inboundSchema),
+  z.lazy(() => Ten$inboundSchema),
+  z.lazy(() => Eleven$inboundSchema),
+  z.lazy(() => Twelve$inboundSchema),
+  z.lazy(() => Thirteen$inboundSchema),
+  z.lazy(() => Fourteen$inboundSchema),
+  z.lazy(() => Fifteen$inboundSchema),
+  z.lazy(() => Sixteen$inboundSchema),
+  z.lazy(() => Seventeen$inboundSchema),
+  z.lazy(() => Eighteen$inboundSchema),
+  z.lazy(() => Nineteen$inboundSchema),
+  z.lazy(() => Twenty$inboundSchema),
+  z.lazy(() => TwentyOne$inboundSchema),
+  z.lazy(() => TwentyTwo$inboundSchema),
+  z.lazy(() => TwentyThree$inboundSchema),
+  z.lazy(() => TwentyFour$inboundSchema),
+  z.lazy(() => TwentyFive$inboundSchema),
+  z.lazy(() => TwentySix$inboundSchema),
+  z.lazy(() => TwentySeven$inboundSchema),
+  z.lazy(() => TwentyEight$inboundSchema),
+  z.lazy(() => TwentyNine$inboundSchema),
+  z.lazy(() => Thirty$inboundSchema),
+  z.lazy(() => ThirtyOne$inboundSchema),
+  z.lazy(() => ThirtyTwo$inboundSchema),
+]);
+
+export function functionParamsFromJSON(
+  jsonString: string,
+): SafeParseResult<FunctionParams, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => FunctionParams$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'FunctionParams' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyFunction$inboundSchema: z.ZodType<
+  GetEvalResponseBodyFunction,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  metadata: z.lazy(() => GetEvalResponseBodyMetadata$inboundSchema),
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  owner: z.string(),
+  created: z.string().default("2026-08-05T15:12:51.947Z"),
+  updated: z.string().default("2026-08-05T15:12:51.947Z"),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  domain_id: z.string(),
+  project_id: z.string().optional(),
+  guardrail_config: z.any().optional(),
+  output_type: GetEvalResponseBodyOutputType$inboundSchema,
+  type: z.literal("function_eval"),
+  function_params: z.union([
+    z.lazy(() => FunctionParams1$inboundSchema),
+    z.lazy(() => FunctionParams2$inboundSchema),
+    z.lazy(() => FunctionParams3$inboundSchema),
+    z.lazy(() => FunctionParams4$inboundSchema),
+    z.lazy(() => FunctionParams5$inboundSchema),
+    z.lazy(() => FunctionParams6$inboundSchema),
+    z.lazy(() => Seven$inboundSchema),
+    z.lazy(() => Eight$inboundSchema),
+    z.lazy(() => Nine$inboundSchema),
+    z.lazy(() => Ten$inboundSchema),
+    z.lazy(() => Eleven$inboundSchema),
+    z.lazy(() => Twelve$inboundSchema),
+    z.lazy(() => Thirteen$inboundSchema),
+    z.lazy(() => Fourteen$inboundSchema),
+    z.lazy(() => Fifteen$inboundSchema),
+    z.lazy(() => Sixteen$inboundSchema),
+    z.lazy(() => Seventeen$inboundSchema),
+    z.lazy(() => Eighteen$inboundSchema),
+    z.lazy(() => Nineteen$inboundSchema),
+    z.lazy(() => Twenty$inboundSchema),
+    z.lazy(() => TwentyOne$inboundSchema),
+    z.lazy(() => TwentyTwo$inboundSchema),
+    z.lazy(() => TwentyThree$inboundSchema),
+    z.lazy(() => TwentyFour$inboundSchema),
+    z.lazy(() => TwentyFive$inboundSchema),
+    z.lazy(() => TwentySix$inboundSchema),
+    z.lazy(() => TwentySeven$inboundSchema),
+    z.lazy(() => TwentyEight$inboundSchema),
+    z.lazy(() => TwentyNine$inboundSchema),
+    z.lazy(() => Thirty$inboundSchema),
+    z.lazy(() => ThirtyOne$inboundSchema),
+    z.lazy(() => ThirtyTwo$inboundSchema),
+  ]),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "domain_id": "domainId",
+    "project_id": "projectId",
+    "guardrail_config": "guardrailConfig",
+    "output_type": "outputType",
+    "function_params": "functionParams",
+  });
+});
+
+export function getEvalResponseBodyFunctionFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyFunction, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyFunction$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyFunction' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyMetadata$inboundSchema: z.ZodType<
+  ResponseBodyMetadata,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  required_model_with_tools_support: z.boolean().optional(),
+  required_retrieval_context: z.boolean().optional(),
+  required_expected_output: z.boolean().optional(),
+  supported_on_input_type: z.boolean().optional(),
+  supported_on_output_type: z.boolean().optional(),
+  support_use_as_guardrail: z.boolean().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "required_model_with_tools_support": "requiredModelWithToolsSupport",
+    "required_retrieval_context": "requiredRetrievalContext",
+    "required_expected_output": "requiredExpectedOutput",
+    "supported_on_input_type": "supportedOnInputType",
+    "supported_on_output_type": "supportedOnOutputType",
+    "support_use_as_guardrail": "supportUseAsGuardrail",
+  });
+});
+
+export function responseBodyMetadataFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyMetadata, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyMetadata$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyMetadata' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyOutputType$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseBodyOutputType
+> = z.nativeEnum(ResponseBodyOutputType);
+
+/** @internal */
+export const ResponseBodyMode$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseBodyMode
+> = z.nativeEnum(ResponseBodyMode);
+
+/** @internal */
+export const ResponseBodyModelParameters$inboundSchema: z.ZodType<
+  ResponseBodyModelParameters,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  temperature: z.number().optional(),
+  max_tokens: z.number().optional(),
+  top_k: z.number().optional(),
+  top_p: z.number().optional(),
+  frequency_penalty: z.number().optional(),
+  presence_penalty: z.number().optional(),
+  reasoning_effort: z.string().optional(),
+  budget_tokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_tokens": "maxTokens",
+    "top_k": "topK",
+    "top_p": "topP",
+    "frequency_penalty": "frequencyPenalty",
+    "presence_penalty": "presencePenalty",
+    "reasoning_effort": "reasoningEffort",
+    "budget_tokens": "budgetTokens",
+  });
+});
+
+export function responseBodyModelParametersFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyModelParameters, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyModelParameters$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyModelParameters' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyModel$inboundSchema: z.ZodType<
+  ResponseBodyModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  integration_id: z.nullable(z.string()).optional(),
+  model_parameters: z.lazy(() => ResponseBodyModelParameters$inboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "integration_id": "integrationId",
+    "model_parameters": "modelParameters",
+  });
+});
+
+export function responseBodyModelFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyModel' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyModelParameters$inboundSchema: z.ZodType<
+  GetEvalResponseBodyModelParameters,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  temperature: z.number().optional(),
+  max_tokens: z.number().optional(),
+  top_k: z.number().optional(),
+  top_p: z.number().optional(),
+  frequency_penalty: z.number().optional(),
+  presence_penalty: z.number().optional(),
+  reasoning_effort: z.string().optional(),
+  budget_tokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_tokens": "maxTokens",
+    "top_k": "topK",
+    "top_p": "topP",
+    "frequency_penalty": "frequencyPenalty",
+    "presence_penalty": "presencePenalty",
+    "reasoning_effort": "reasoningEffort",
+    "budget_tokens": "budgetTokens",
+  });
+});
+
+export function getEvalResponseBodyModelParametersFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyModelParameters, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyModelParameters$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyModelParameters' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponseModel$inboundSchema: z.ZodType<
+  GetEvalResponseBodyEvalsResponseModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  integration_id: z.nullable(z.string()).optional(),
+  model_parameters: z.lazy(() =>
+    GetEvalResponseBodyModelParameters$inboundSchema
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "integration_id": "integrationId",
+    "model_parameters": "modelParameters",
+  });
+});
+
+export function getEvalResponseBodyEvalsResponseModelFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyEvalsResponseModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponseModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponseModel' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyRetry$inboundSchema: z.ZodType<
+  ResponseBodyRetry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int().default(2),
+  on_codes: z.array(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "on_codes": "onCodes",
+  });
+});
+
+export function responseBodyRetryFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyRetry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyRetry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyRetry' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponseModelParameters$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponseModelParameters,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    temperature: z.number().optional(),
+    max_tokens: z.number().optional(),
+    top_k: z.number().optional(),
+    top_p: z.number().optional(),
+    frequency_penalty: z.number().optional(),
+    presence_penalty: z.number().optional(),
+    reasoning_effort: z.string().optional(),
+    budget_tokens: z.number().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "max_tokens": "maxTokens",
+      "top_k": "topK",
+      "top_p": "topP",
+      "frequency_penalty": "frequencyPenalty",
+      "presence_penalty": "presencePenalty",
+      "reasoning_effort": "reasoningEffort",
+      "budget_tokens": "budgetTokens",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponseModelParametersFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponseModelParameters,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponseModelParameters$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponseModelParameters' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ApplicationJSONModel$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponse200ApplicationJSONModel,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    id: z.string(),
+    integration_id: z.nullable(z.string()).optional(),
+    model_parameters: z.lazy(() =>
+      GetEvalResponseBodyEvalsResponseModelParameters$inboundSchema
+    ).optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "integration_id": "integrationId",
+      "model_parameters": "modelParameters",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponse200ApplicationJSONModelFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200ApplicationJSONModel,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200ApplicationJSONModel$inboundSchema
+        .parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200ApplicationJSONModel' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyFallbacks$inboundSchema: z.ZodType<
+  ResponseBodyFallbacks,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.lazy(() =>
+    GetEvalResponseBodyEvalsResponse200ApplicationJSONModel$inboundSchema
+  ),
+});
+
+export function responseBodyFallbacksFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyFallbacks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyFallbacks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyFallbacks' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyJudges$inboundSchema: z.ZodType<
+  ResponseBodyJudges,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.lazy(() => GetEvalResponseBodyEvalsResponseModel$inboundSchema),
+  retry: z.lazy(() => ResponseBodyRetry$inboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => ResponseBodyFallbacks$inboundSchema))
+    .optional(),
+});
+
+export function responseBodyJudgesFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyJudges, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyJudges$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyJudges' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsModelParameters$inboundSchema: z.ZodType<
+  GetEvalResponseBodyEvalsModelParameters,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  temperature: z.number().optional(),
+  max_tokens: z.number().optional(),
+  top_k: z.number().optional(),
+  top_p: z.number().optional(),
+  frequency_penalty: z.number().optional(),
+  presence_penalty: z.number().optional(),
+  reasoning_effort: z.string().optional(),
+  budget_tokens: z.number().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "max_tokens": "maxTokens",
+    "top_k": "topK",
+    "top_p": "topP",
+    "frequency_penalty": "frequencyPenalty",
+    "presence_penalty": "presencePenalty",
+    "reasoning_effort": "reasoningEffort",
+    "budget_tokens": "budgetTokens",
+  });
+});
+
+export function getEvalResponseBodyEvalsModelParametersFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsModelParameters,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsModelParameters$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetEvalResponseBodyEvalsModelParameters' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsModel$inboundSchema: z.ZodType<
+  GetEvalResponseBodyEvalsModel,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  integration_id: z.nullable(z.string()).optional(),
+  model_parameters: z.lazy(() =>
+    GetEvalResponseBodyEvalsModelParameters$inboundSchema
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "integration_id": "integrationId",
+    "model_parameters": "modelParameters",
+  });
+});
+
+export function getEvalResponseBodyEvalsModelFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyEvalsModel, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyEvalsModel$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyEvalsModel' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyRetry$inboundSchema: z.ZodType<
+  GetEvalResponseBodyRetry,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  count: z.number().int().default(2),
+  on_codes: z.array(z.number().int()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "on_codes": "onCodes",
+  });
+});
+
+export function getEvalResponseBodyRetryFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyRetry, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyRetry$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyRetry' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200ModelParameters$inboundSchema:
+  z.ZodType<
+    GetEvalResponseBodyEvalsResponse200ModelParameters,
+    z.ZodTypeDef,
+    unknown
+  > = z.object({
+    temperature: z.number().optional(),
+    max_tokens: z.number().optional(),
+    top_k: z.number().optional(),
+    top_p: z.number().optional(),
+    frequency_penalty: z.number().optional(),
+    presence_penalty: z.number().optional(),
+    reasoning_effort: z.string().optional(),
+    budget_tokens: z.number().optional(),
+  }).transform((v) => {
+    return remap$(v, {
+      "max_tokens": "maxTokens",
+      "top_k": "topK",
+      "top_p": "topP",
+      "frequency_penalty": "frequencyPenalty",
+      "presence_penalty": "presencePenalty",
+      "reasoning_effort": "reasoningEffort",
+      "budget_tokens": "budgetTokens",
+    });
+  });
+
+export function getEvalResponseBodyEvalsResponse200ModelParametersFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200ModelParameters,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200ModelParameters$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200ModelParameters' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyEvalsResponse200Model$inboundSchema: z.ZodType<
+  GetEvalResponseBodyEvalsResponse200Model,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string(),
+  integration_id: z.nullable(z.string()).optional(),
+  model_parameters: z.lazy(() =>
+    GetEvalResponseBodyEvalsResponse200ModelParameters$inboundSchema
+  ).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "integration_id": "integrationId",
+    "model_parameters": "modelParameters",
+  });
+});
+
+export function getEvalResponseBodyEvalsResponse200ModelFromJSON(
+  jsonString: string,
+): SafeParseResult<
+  GetEvalResponseBodyEvalsResponse200Model,
+  SDKValidationError
+> {
+  return safeParse(
+    jsonString,
+    (x) =>
+      GetEvalResponseBodyEvalsResponse200Model$inboundSchema.parse(
+        JSON.parse(x),
+      ),
+    `Failed to parse 'GetEvalResponseBodyEvalsResponse200Model' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBodyFallbacks$inboundSchema: z.ZodType<
+  GetEvalResponseBodyFallbacks,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.lazy(() => GetEvalResponseBodyEvalsResponse200Model$inboundSchema),
+});
+
+export function getEvalResponseBodyFallbacksFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBodyFallbacks, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBodyFallbacks$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBodyFallbacks' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyReplacementJudges$inboundSchema: z.ZodType<
+  ResponseBodyReplacementJudges,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  model: z.lazy(() => GetEvalResponseBodyEvalsModel$inboundSchema),
+  retry: z.lazy(() => GetEvalResponseBodyRetry$inboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => GetEvalResponseBodyFallbacks$inboundSchema))
+    .optional(),
+});
+
+export function responseBodyReplacementJudgesFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyReplacementJudges, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyReplacementJudges$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyReplacementJudges' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyTieValue$inboundSchema: z.ZodNativeEnum<
+  typeof ResponseBodyTieValue
+> = z.nativeEnum(ResponseBodyTieValue);
+
+/** @internal */
+export const ResponseBodyJury$inboundSchema: z.ZodType<
+  ResponseBodyJury,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  judges: z.array(z.lazy(() => ResponseBodyJudges$inboundSchema)),
+  replacement_judges: z.array(
+    z.lazy(() => ResponseBodyReplacementJudges$inboundSchema),
+  ).optional(),
+  min_successful_judges: z.number().int().default(2),
+  tie_value: ResponseBodyTieValue$inboundSchema.default("Tie"),
+}).transform((v) => {
+  return remap$(v, {
+    "replacement_judges": "replacementJudges",
+    "min_successful_judges": "minSuccessfulJudges",
+    "tie_value": "tieValue",
+  });
+});
+
+export function responseBodyJuryFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyJury, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyJury$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyJury' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyCategoricalLabels$inboundSchema: z.ZodType<
+  ResponseBodyCategoricalLabels,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  value: z.string(),
+  description: z.string().optional(),
+});
+
+export function responseBodyCategoricalLabelsFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyCategoricalLabels, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyCategoricalLabels$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyCategoricalLabels' from JSON`,
+  );
+}
+
+/** @internal */
+export const ResponseBodyLLM$inboundSchema: z.ZodType<
+  ResponseBodyLLM,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  enabled: z.boolean().default(true),
+  metadata: z.lazy(() => ResponseBodyMetadata$inboundSchema),
+  _id: z.string(),
+  display_name: z.string(),
+  description: z.string(),
+  owner: z.string(),
+  created: z.string().default("2026-08-05T15:12:51.947Z"),
+  updated: z.string().default("2026-08-05T15:12:51.947Z"),
+  created_by_id: z.nullable(z.string()).optional(),
+  updated_by_id: z.nullable(z.string()).optional(),
+  domain_id: z.string(),
+  project_id: z.string().optional(),
+  guardrail_config: z.any().optional(),
+  output_type: ResponseBodyOutputType$inboundSchema.optional(),
+  type: z.literal("llm_eval"),
+  mode: z.nullable(ResponseBodyMode$inboundSchema).optional(),
+  repetitions: z.nullable(z.number().int()).optional(),
+  model: z.lazy(() => ResponseBodyModel$inboundSchema).optional(),
+  jury: z.nullable(z.lazy(() => ResponseBodyJury$inboundSchema)).optional(),
+  prompt: z.string(),
+  categories: z.nullable(z.array(z.string())).optional(),
+  categorical_labels: z.nullable(
+    z.array(z.lazy(() => ResponseBodyCategoricalLabels$inboundSchema)),
+  ).optional(),
+  dataset_id: z.nullable(z.string()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "_id": "id",
+    "display_name": "displayName",
+    "created_by_id": "createdById",
+    "updated_by_id": "updatedById",
+    "domain_id": "domainId",
+    "project_id": "projectId",
+    "guardrail_config": "guardrailConfig",
+    "output_type": "outputType",
+    "categorical_labels": "categoricalLabels",
+    "dataset_id": "datasetId",
+  });
+});
+
+export function responseBodyLLMFromJSON(
+  jsonString: string,
+): SafeParseResult<ResponseBodyLLM, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => ResponseBodyLLM$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'ResponseBodyLLM' from JSON`,
+  );
+}
+
+/** @internal */
+export const GetEvalResponseBody$inboundSchema: z.ZodType<
+  GetEvalResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  z.lazy(() => ResponseBodyLLM$inboundSchema),
+  z.lazy(() => GetEvalResponseBodyFunction$inboundSchema),
+  z.lazy(() => Ragas$inboundSchema),
+  z.lazy(() => Json$inboundSchema),
+  z.lazy(() => GetEvalResponseBodyHTTP$inboundSchema),
+  z.lazy(() => ResponseBodyPython$inboundSchema),
+  z.lazy(() => Typescript$inboundSchema),
+  z.lazy(() => BedrockGuardrail$inboundSchema),
+]);
+
+export function getEvalResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<GetEvalResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => GetEvalResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'GetEvalResponseBody' from JSON`,
+  );
+}