@orq-ai/node 4.11.0-rc.53 → 4.11.0-rc.55

package/src/models/operations/createeval.ts

@@ -7,6 +7,7 @@ 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 * as components from "../components/index.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
 export const GuardrailConfigOperator = {
@@ -83,7 +84,7 @@ export type Python = {
   key: string;
 };
 
-export const CreateEvalGuardrailConfigEvalsRequestOperator = {
+export const CreateEvalGuardrailConfigEvalsOperator = {
   Eq: "eq",
   Ne: "ne",
   Gt: "gt",
@@ -91,26 +92,26 @@ export const CreateEvalGuardrailConfigEvalsRequestOperator = {
   Lt: "lt",
   Lte: "lte",
 } as const;
-export type CreateEvalGuardrailConfigEvalsRequestOperator = ClosedEnum<
-  typeof CreateEvalGuardrailConfigEvalsRequestOperator
+export type CreateEvalGuardrailConfigEvalsOperator = ClosedEnum<
+  typeof CreateEvalGuardrailConfigEvalsOperator
 >;
 
-export type CreateEvalGuardrailConfigEvalsRequestNumber = {
+export type CreateEvalGuardrailConfigEvalsNumber = {
   enabled?: boolean | undefined;
   alertOnFailure?: boolean | undefined;
   type: "number";
   value: number;
-  operator: CreateEvalGuardrailConfigEvalsRequestOperator;
+  operator: CreateEvalGuardrailConfigEvalsOperator;
 };
 
-export type CreateEvalGuardrailConfigEvalsRequestCategorical = {
+export type CreateEvalGuardrailConfigEvalsCategorical = {
   enabled?: boolean | undefined;
   alertOnFailure?: boolean | undefined;
   type: "categorical";
   values: Array<string>;
 };
 
-export type CreateEvalGuardrailConfigEvalsRequestBoolean = {
+export type CreateEvalGuardrailConfigEvalsBoolean = {
   enabled?: boolean | undefined;
   alertOnFailure?: boolean | undefined;
   type: "boolean";
@@ -118,9 +119,9 @@ export type CreateEvalGuardrailConfigEvalsRequestBoolean = {
 };
 
 export type LLMGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsRequestBoolean
-  | CreateEvalGuardrailConfigEvalsRequestCategorical
-  | CreateEvalGuardrailConfigEvalsRequestNumber;
+  | CreateEvalGuardrailConfigEvalsBoolean
+  | CreateEvalGuardrailConfigEvalsCategorical
+  | CreateEvalGuardrailConfigEvalsNumber;
 
 /**
  * The type of output expected from the evaluator
@@ -190,9 +191,9 @@ export type LLMJury = {
 
 export type Llm2 = {
   guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsRequestBoolean
-    | CreateEvalGuardrailConfigEvalsRequestCategorical
-    | CreateEvalGuardrailConfigEvalsRequestNumber
+    | CreateEvalGuardrailConfigEvalsBoolean
+    | CreateEvalGuardrailConfigEvalsCategorical
+    | CreateEvalGuardrailConfigEvalsNumber
     | null
     | undefined;
   /**
@@ -323,4112 +324,878 @@ export type Llm = Llm1 | Llm2;
 
 export type CreateEvalRequestBody = Python | Llm1 | Llm2;
 
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator =
-  {
-    Eq: "eq",
-    Ne: "ne",
-    Gt: "gt",
-    Gte: "gte",
-    Lt: "lt",
-    Lte: "lte",
-  } as const;
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator =
-  ClosedEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator
-  >;
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "number";
-    value: number;
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "categorical";
-    values: Array<string>;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "boolean";
-    value: boolean;
-  };
-
-export type CreateEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number;
-
-export const CreateEvalResponseBodyEvalsResponse200ApplicationJSONType = {
-  TypescriptEval: "typescript_eval",
-} as const;
-export type CreateEvalResponseBodyEvalsResponse200ApplicationJSONType =
-  ClosedEnum<typeof CreateEvalResponseBodyEvalsResponse200ApplicationJSONType>;
-
-export type Typescript = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number
-    | null
-    | undefined;
-  code: string;
-  type: CreateEvalResponseBodyEvalsResponse200ApplicationJSONType;
-  key: string;
-};
-
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator =
-  {
-    Eq: "eq",
-    Ne: "ne",
-    Gt: "gt",
-    Gte: "gte",
-    Lt: "lt",
-    Lte: "lte",
-  } as const;
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator =
-  ClosedEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator
-  >;
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "number";
-    value: number;
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "categorical";
-    values: Array<string>;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "boolean";
-    value: boolean;
-  };
-
-export type CreateEvalResponseBodyEvalsResponse200GuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber;
-
-export const CreateEvalResponseBodyEvalsResponse200Type = {
-  Ragas: "ragas",
-} as const;
-export type CreateEvalResponseBodyEvalsResponse200Type = ClosedEnum<
-  typeof CreateEvalResponseBodyEvalsResponse200Type
->;
-
-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>;
+/**
+ * Successfully created an evaluator
+ */
+export type CreateEvalResponseBody =
+  | components.EvaluatorResponseLlm
+  | components.EvaluatorResponseJsonSchema
+  | components.EvaluatorResponseHttp
+  | components.EvaluatorResponsePython
+  | components.EvaluatorResponseFunction
+  | components.EvaluatorResponseRagas
+  | components.EvaluatorResponseTypescript;
 
-export type Ragas = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber
-    | null
-    | undefined;
-  type: CreateEvalResponseBodyEvalsResponse200Type;
-  ragasMetric: RagasMetric;
-  key: string;
-  model: string;
-};
+/** @internal */
+export const GuardrailConfigOperator$outboundSchema: z.ZodNativeEnum<
+  typeof GuardrailConfigOperator
+> = z.nativeEnum(GuardrailConfigOperator);
 
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator =
-  {
-    Eq: "eq",
-    Ne: "ne",
-    Gt: "gt",
-    Gte: "gte",
-    Lt: "lt",
-    Lte: "lte",
-  } as const;
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator =
-  ClosedEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator
-  >;
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber = {
+/** @internal */
+export type GuardrailConfigNumber$Outbound = {
   enabled: boolean;
-  alertOnFailure: boolean;
+  alert_on_failure: boolean;
   type: "number";
   value: number;
-  operator: CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator;
-};
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "categorical";
-    values: Array<string>;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
+  operator: string;
 };
 
-export type CreateEvalResponseBodyEvalsResponseGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber;
-
-export const CreateEvalResponseBodyEvalsResponseType = {
-  FunctionEval: "function_eval",
-} as const;
-export type CreateEvalResponseBodyEvalsResponseType = ClosedEnum<
-  typeof CreateEvalResponseBodyEvalsResponseType
->;
-
-export type ThirtyTwo = {
-  type: "grammar_diversity";
-};
+/** @internal */
+export const GuardrailConfigNumber$outboundSchema: z.ZodType<
+  GuardrailConfigNumber$Outbound,
+  z.ZodTypeDef,
+  GuardrailConfigNumber
+> = z.object({
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("number"),
+  value: z.number(),
+  operator: GuardrailConfigOperator$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    alertOnFailure: "alert_on_failure",
+  });
+});
 
-export type ThirtyOne = {
-  type: "lexical_repetition";
-};
+export function guardrailConfigNumberToJSON(
+  guardrailConfigNumber: GuardrailConfigNumber,
+): string {
+  return JSON.stringify(
+    GuardrailConfigNumber$outboundSchema.parse(guardrailConfigNumber),
+  );
+}
 
-export type Thirty = {
-  type: "sentences_count";
+/** @internal */
+export type GuardrailConfigCategorical$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "categorical";
+  values: Array<string>;
 };
 
-export type TwentyNine = {
-  type: "words_count";
-};
+/** @internal */
+export const GuardrailConfigCategorical$outboundSchema: z.ZodType<
+  GuardrailConfigCategorical$Outbound,
+  z.ZodTypeDef,
+  GuardrailConfigCategorical
+> = z.object({
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("categorical"),
+  values: z.array(z.string()),
+}).transform((v) => {
+  return remap$(v, {
+    alertOnFailure: "alert_on_failure",
+  });
+});
 
-export type TwentyEight = {
-  type: "gse_english_level";
-};
+export function guardrailConfigCategoricalToJSON(
+  guardrailConfigCategorical: GuardrailConfigCategorical,
+): string {
+  return JSON.stringify(
+    GuardrailConfigCategorical$outboundSchema.parse(guardrailConfigCategorical),
+  );
+}
 
-export type TwentySeven = {
-  type: "flesch_reading_ease";
+/** @internal */
+export type GuardrailConfigBoolean$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "boolean";
+  value: boolean;
 };
 
-export type TwentySix = {
-  type: "most_repeated_words";
-};
+/** @internal */
+export const GuardrailConfigBoolean$outboundSchema: z.ZodType<
+  GuardrailConfigBoolean$Outbound,
+  z.ZodTypeDef,
+  GuardrailConfigBoolean
+> = z.object({
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("boolean"),
+  value: z.boolean(),
+}).transform((v) => {
+  return remap$(v, {
+    alertOnFailure: "alert_on_failure",
+  });
+});
 
-export type TwentyFive = {
-  type: "keywords_match";
-  keywords: Array<string>;
-};
+export function guardrailConfigBooleanToJSON(
+  guardrailConfigBoolean: GuardrailConfigBoolean,
+): string {
+  return JSON.stringify(
+    GuardrailConfigBoolean$outboundSchema.parse(guardrailConfigBoolean),
+  );
+}
 
-export type TwentyFour = {
-  type: "levenshtein_distance";
-};
+/** @internal */
+export type RequestBodyGuardrailConfig$Outbound =
+  | GuardrailConfigBoolean$Outbound
+  | GuardrailConfigCategorical$Outbound
+  | GuardrailConfigNumber$Outbound;
 
-export type TwentyThree = {
-  type: "cosine_similarity";
-};
+/** @internal */
+export const RequestBodyGuardrailConfig$outboundSchema: z.ZodType<
+  RequestBodyGuardrailConfig$Outbound,
+  z.ZodTypeDef,
+  RequestBodyGuardrailConfig
+> = z.union([
+  z.lazy(() => GuardrailConfigBoolean$outboundSchema),
+  z.lazy(() => GuardrailConfigCategorical$outboundSchema),
+  z.lazy(() => GuardrailConfigNumber$outboundSchema),
+]);
 
-export type TwentyTwo = {
-  type: "meteor_score";
-};
+export function requestBodyGuardrailConfigToJSON(
+  requestBodyGuardrailConfig: RequestBodyGuardrailConfig,
+): string {
+  return JSON.stringify(
+    RequestBodyGuardrailConfig$outboundSchema.parse(requestBodyGuardrailConfig),
+  );
+}
 
-export type TwentyOne = {
-  type: "rouge_n";
-};
+/** @internal */
+export const OutputType$outboundSchema: z.ZodNativeEnum<typeof OutputType> = z
+  .nativeEnum(OutputType);
 
-export type Twenty = {
-  type: "bleu_score";
-};
+/** @internal */
+export const RequestBodyType$outboundSchema: z.ZodNativeEnum<
+  typeof RequestBodyType
+> = z.nativeEnum(RequestBodyType);
 
-export type Nineteen = {
-  type: "bert_score";
+/** @internal */
+export type Python$Outbound = {
+  guardrail_config?:
+    | GuardrailConfigBoolean$Outbound
+    | GuardrailConfigCategorical$Outbound
+    | GuardrailConfigNumber$Outbound
+    | null
+    | undefined;
+  output_type?: string | undefined;
+  code: string;
+  type: string;
+  path: string;
+  description: string;
+  key: string;
 };
 
-export type Eighteen = {
-  type: "moderations_google";
-};
+/** @internal */
+export const Python$outboundSchema: z.ZodType<
+  Python$Outbound,
+  z.ZodTypeDef,
+  Python
+> = z.object({
+  guardrailConfig: z.nullable(
+    z.union([
+      z.lazy(() => GuardrailConfigBoolean$outboundSchema),
+      z.lazy(() => GuardrailConfigCategorical$outboundSchema),
+      z.lazy(() => GuardrailConfigNumber$outboundSchema),
+    ]),
+  ).optional(),
+  outputType: OutputType$outboundSchema.optional(),
+  code: z.string(),
+  type: RequestBodyType$outboundSchema,
+  path: z.string(),
+  description: z.string().default(""),
+  key: z.string(),
+}).transform((v) => {
+  return remap$(v, {
+    guardrailConfig: "guardrail_config",
+    outputType: "output_type",
+  });
+});
 
-export type Seventeen = {
-  type: "moderations_openai";
-};
+export function pythonToJSON(python: Python): string {
+  return JSON.stringify(Python$outboundSchema.parse(python));
+}
 
-export type Sixteen = {
-  type: "is_valid_json";
-};
+/** @internal */
+export const CreateEvalGuardrailConfigEvalsOperator$outboundSchema:
+  z.ZodNativeEnum<typeof CreateEvalGuardrailConfigEvalsOperator> = z.nativeEnum(
+    CreateEvalGuardrailConfigEvalsOperator,
+  );
 
-export type Fifteen = {
-  type: "regex";
-  pattern: string;
+/** @internal */
+export type CreateEvalGuardrailConfigEvalsNumber$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "number";
+  value: number;
+  operator: string;
 };
 
-export type Fourteen = {
-  type: "one_line";
-};
+/** @internal */
+export const CreateEvalGuardrailConfigEvalsNumber$outboundSchema: z.ZodType<
+  CreateEvalGuardrailConfigEvalsNumber$Outbound,
+  z.ZodTypeDef,
+  CreateEvalGuardrailConfigEvalsNumber
+> = z.object({
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("number"),
+  value: z.number(),
+  operator: CreateEvalGuardrailConfigEvalsOperator$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    alertOnFailure: "alert_on_failure",
+  });
+});
 
-export type Thirteen = {
-  type: "length_greater_than";
-  value: number;
-};
+export function createEvalGuardrailConfigEvalsNumberToJSON(
+  createEvalGuardrailConfigEvalsNumber: CreateEvalGuardrailConfigEvalsNumber,
+): string {
+  return JSON.stringify(
+    CreateEvalGuardrailConfigEvalsNumber$outboundSchema.parse(
+      createEvalGuardrailConfigEvalsNumber,
+    ),
+  );
+}
 
-export type Twelve = {
-  type: "length_between";
-  min: number;
-  max: number;
+/** @internal */
+export type CreateEvalGuardrailConfigEvalsCategorical$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "categorical";
+  values: Array<string>;
 };
 
-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 Six = {
-  type: "contains_url";
-};
-
-export type Five = {
-  type: "contains_email";
-};
-
-export type CreateEvalFunctionParams4 = {
-  type: "contains_any";
-  keywords: Array<string>;
-};
-
-export type CreateEvalFunctionParams3 = {
-  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
-  | CreateEvalFunctionParams3
-  | CreateEvalFunctionParams4
-  | Five
-  | Six
-  | 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 CreateEvalResponseBodyFunction = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber
-    | null
-    | undefined;
-  type: CreateEvalResponseBodyEvalsResponseType;
-  functionParams:
-    | FunctionParams1
-    | FunctionParams2
-    | CreateEvalFunctionParams3
-    | CreateEvalFunctionParams4
-    | Five
-    | Six
-    | 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;
-  key: string;
-};
-
-export const CreateEvalGuardrailConfigEvalsResponse200Operator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type CreateEvalGuardrailConfigEvalsResponse200Operator = ClosedEnum<
-  typeof CreateEvalGuardrailConfigEvalsResponse200Operator
->;
-
-export type CreateEvalGuardrailConfigEvalsResponse200Number = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: CreateEvalGuardrailConfigEvalsResponse200Operator;
-};
-
-export type CreateEvalGuardrailConfigEvalsResponse200Categorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type CreateEvalGuardrailConfigEvalsResponse200Boolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type CreateEvalResponseBodyEvalsGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponse200Boolean
-  | CreateEvalGuardrailConfigEvalsResponse200Categorical
-  | CreateEvalGuardrailConfigEvalsResponse200Number;
-
-export const CreateEvalResponseBodyEvalsType = {
-  PythonEval: "python_eval",
-} as const;
-export type CreateEvalResponseBodyEvalsType = ClosedEnum<
-  typeof CreateEvalResponseBodyEvalsType
->;
-
-export type ResponseBodyPython = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponse200Boolean
-    | CreateEvalGuardrailConfigEvalsResponse200Categorical
-    | CreateEvalGuardrailConfigEvalsResponse200Number
-    | null
-    | undefined;
-  code: string;
-  type: CreateEvalResponseBodyEvalsType;
-  key: string;
-};
-
-export const CreateEvalGuardrailConfigEvalsResponseOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type CreateEvalGuardrailConfigEvalsResponseOperator = ClosedEnum<
-  typeof CreateEvalGuardrailConfigEvalsResponseOperator
->;
-
-export type CreateEvalGuardrailConfigEvalsResponseNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: CreateEvalGuardrailConfigEvalsResponseOperator;
-};
-
-export type CreateEvalGuardrailConfigEvalsResponseCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type CreateEvalGuardrailConfigEvalsResponseBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type CreateEvalResponseBodyGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponseBoolean
-  | CreateEvalGuardrailConfigEvalsResponseCategorical
-  | CreateEvalGuardrailConfigEvalsResponseNumber;
-
-export const CreateEvalResponseBodyType = {
-  HttpEval: "http_eval",
-} as const;
-export type CreateEvalResponseBodyType = ClosedEnum<
-  typeof CreateEvalResponseBodyType
->;
-
-export const CreateEvalResponseBodyMethod = {
-  Get: "GET",
-  Post: "POST",
-} as const;
-export type CreateEvalResponseBodyMethod = ClosedEnum<
-  typeof CreateEvalResponseBodyMethod
->;
-
-export type CreateEvalResponseBodyHTTP = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponseBoolean
-    | CreateEvalGuardrailConfigEvalsResponseCategorical
-    | CreateEvalGuardrailConfigEvalsResponseNumber
-    | null
-    | undefined;
-  type: CreateEvalResponseBodyType;
-  url: string;
-  method: CreateEvalResponseBodyMethod;
-  headers: { [k: string]: string };
-  payload: { [k: string]: any };
-  key: string;
-};
-
-export const CreateEvalGuardrailConfigEvalsOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type CreateEvalGuardrailConfigEvalsOperator = ClosedEnum<
-  typeof CreateEvalGuardrailConfigEvalsOperator
->;
-
-export type CreateEvalGuardrailConfigEvalsNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: CreateEvalGuardrailConfigEvalsOperator;
-};
-
-export type CreateEvalGuardrailConfigEvalsCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type CreateEvalGuardrailConfigEvalsBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type ResponseBodyGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsBoolean
-  | CreateEvalGuardrailConfigEvalsCategorical
-  | CreateEvalGuardrailConfigEvalsNumber;
-
-export const ResponseBodyType = {
-  JsonSchema: "json_schema",
-} as const;
-export type ResponseBodyType = ClosedEnum<typeof ResponseBodyType>;
-
-export type Json = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsBoolean
-    | CreateEvalGuardrailConfigEvalsCategorical
-    | CreateEvalGuardrailConfigEvalsNumber
-    | null
-    | undefined;
-  type: ResponseBodyType;
-  schema: string;
-  key: string;
-};
-
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator =
-  {
-    Eq: "eq",
-    Ne: "ne",
-    Gt: "gt",
-    Gte: "gte",
-    Lt: "lt",
-    Lte: "lte",
-  } as const;
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator =
-  ClosedEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator
-  >;
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "number";
-    value: number;
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "categorical";
-    values: Array<string>;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "boolean";
-    value: boolean;
-  };
-
-export type CreateEvalLLMEvalsResponseGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number;
-
-export const CreateEvalLLMEvalsResponseType = {
-  LlmEval: "llm_eval",
-} as const;
-export type CreateEvalLLMEvalsResponseType = ClosedEnum<
-  typeof CreateEvalLLMEvalsResponseType
->;
-
-export type CreateEvalLLMEvalsCategoricalLabels = {
-  value: string;
-  description?: string | undefined;
-};
-
-export type CreateEvalLLMEvalsResponseRetry = {
-  count: number;
-  onCodes?: Array<number> | undefined;
-};
-
-export type CreateEvalLLMEvalsResponseFallbacks = {
-  model: string;
-};
-
-export type CreateEvalLLMJudges = {
-  model: string;
-  retry?: CreateEvalLLMEvalsResponseRetry | undefined;
-  fallbacks?: Array<CreateEvalLLMEvalsResponseFallbacks> | undefined;
-};
-
-export type CreateEvalLLMEvalsRetry = {
-  count: number;
-  onCodes?: Array<number> | undefined;
-};
-
-export type CreateEvalLLMEvalsFallbacks = {
-  model: string;
-};
-
-export type CreateEvalLLMReplacementJudges = {
-  model: string;
-  retry?: CreateEvalLLMEvalsRetry | undefined;
-  fallbacks?: Array<CreateEvalLLMEvalsFallbacks> | undefined;
-};
-
-export const CreateEvalLLMTieValue = {
-  Tie: "Tie",
-} as const;
-export type CreateEvalLLMTieValue = ClosedEnum<typeof CreateEvalLLMTieValue>;
-
-export type CreateEvalLLMJury = {
-  judges: Array<CreateEvalLLMJudges>;
-  replacementJudges?: Array<CreateEvalLLMReplacementJudges> | undefined;
-  minSuccessfulJudges: number;
-  tieValue: CreateEvalLLMTieValue;
-};
-
-export type CreateEvalLlm2 = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number
-    | null
-    | undefined;
-  type: CreateEvalLLMEvalsResponseType;
-  repetitions?: number | null | undefined;
-  prompt: string;
-  categories?: Array<string> | null | undefined;
-  categoricalLabels?:
-    | Array<CreateEvalLLMEvalsCategoricalLabels>
-    | null
-    | undefined;
-  datasetId?: string | undefined;
-  key: string;
-  mode: "jury";
-  jury: CreateEvalLLMJury;
-};
-
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator =
-  {
-    Eq: "eq",
-    Ne: "ne",
-    Gt: "gt",
-    Gte: "gte",
-    Lt: "lt",
-    Lte: "lte",
-  } as const;
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator =
-  ClosedEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator
-  >;
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "number";
-    value: number;
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "categorical";
-    values: Array<string>;
-  };
-
-export type CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean =
-  {
-    enabled: boolean;
-    alertOnFailure: boolean;
-    type: "boolean";
-    value: boolean;
-  };
-
-export type CreateEvalLLMEvalsGuardrailConfig =
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical
-  | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber;
-
-export const CreateEvalLLMEvalsType = {
-  LlmEval: "llm_eval",
-} as const;
-export type CreateEvalLLMEvalsType = ClosedEnum<typeof CreateEvalLLMEvalsType>;
-
-export type CreateEvalLLMEvalsResponseCategoricalLabels = {
-  value: string;
-  description?: string | undefined;
-};
-
-export type CreateEvalLlm1 = {
-  id: string;
-  description: string;
-  created: string;
-  updated: string;
-  updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical
-    | CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber
-    | null
-    | undefined;
-  type: CreateEvalLLMEvalsType;
-  repetitions?: number | null | undefined;
-  prompt: string;
-  categories?: Array<string> | null | undefined;
-  categoricalLabels?:
-    | Array<CreateEvalLLMEvalsResponseCategoricalLabels>
-    | null
-    | undefined;
-  datasetId?: string | undefined;
-  key: string;
-  mode: "single";
-  model: string;
-};
-
-export type ResponseBodyLLM = CreateEvalLlm1 | CreateEvalLlm2;
-
-/**
- * Successfully created an evaluator
- */
-export type CreateEvalResponseBody =
-  | CreateEvalResponseBodyHTTP
-  | Ragas
-  | Json
-  | ResponseBodyPython
-  | CreateEvalResponseBodyFunction
-  | Typescript
-  | CreateEvalLlm1
-  | CreateEvalLlm2;
-
-/** @internal */
-export const GuardrailConfigOperator$outboundSchema: z.ZodNativeEnum<
-  typeof GuardrailConfigOperator
-> = z.nativeEnum(GuardrailConfigOperator);
-
-/** @internal */
-export type GuardrailConfigNumber$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "number";
-  value: number;
-  operator: string;
-};
-
-/** @internal */
-export const GuardrailConfigNumber$outboundSchema: z.ZodType<
-  GuardrailConfigNumber$Outbound,
-  z.ZodTypeDef,
-  GuardrailConfigNumber
-> = z.object({
-  enabled: z.boolean().default(true),
-  alertOnFailure: z.boolean().default(false),
-  type: z.literal("number"),
-  value: z.number(),
-  operator: GuardrailConfigOperator$outboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    alertOnFailure: "alert_on_failure",
-  });
-});
-
-export function guardrailConfigNumberToJSON(
-  guardrailConfigNumber: GuardrailConfigNumber,
-): string {
-  return JSON.stringify(
-    GuardrailConfigNumber$outboundSchema.parse(guardrailConfigNumber),
-  );
-}
-
-/** @internal */
-export type GuardrailConfigCategorical$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-/** @internal */
-export const GuardrailConfigCategorical$outboundSchema: z.ZodType<
-  GuardrailConfigCategorical$Outbound,
-  z.ZodTypeDef,
-  GuardrailConfigCategorical
-> = z.object({
-  enabled: z.boolean().default(true),
-  alertOnFailure: z.boolean().default(false),
-  type: z.literal("categorical"),
-  values: z.array(z.string()),
-}).transform((v) => {
-  return remap$(v, {
-    alertOnFailure: "alert_on_failure",
-  });
-});
-
-export function guardrailConfigCategoricalToJSON(
-  guardrailConfigCategorical: GuardrailConfigCategorical,
-): string {
-  return JSON.stringify(
-    GuardrailConfigCategorical$outboundSchema.parse(guardrailConfigCategorical),
-  );
-}
-
-/** @internal */
-export type GuardrailConfigBoolean$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-/** @internal */
-export const GuardrailConfigBoolean$outboundSchema: z.ZodType<
-  GuardrailConfigBoolean$Outbound,
-  z.ZodTypeDef,
-  GuardrailConfigBoolean
-> = z.object({
-  enabled: z.boolean().default(true),
-  alertOnFailure: z.boolean().default(false),
-  type: z.literal("boolean"),
-  value: z.boolean(),
-}).transform((v) => {
-  return remap$(v, {
-    alertOnFailure: "alert_on_failure",
-  });
-});
-
-export function guardrailConfigBooleanToJSON(
-  guardrailConfigBoolean: GuardrailConfigBoolean,
-): string {
-  return JSON.stringify(
-    GuardrailConfigBoolean$outboundSchema.parse(guardrailConfigBoolean),
-  );
-}
-
-/** @internal */
-export type RequestBodyGuardrailConfig$Outbound =
-  | GuardrailConfigBoolean$Outbound
-  | GuardrailConfigCategorical$Outbound
-  | GuardrailConfigNumber$Outbound;
-
-/** @internal */
-export const RequestBodyGuardrailConfig$outboundSchema: z.ZodType<
-  RequestBodyGuardrailConfig$Outbound,
-  z.ZodTypeDef,
-  RequestBodyGuardrailConfig
-> = z.union([
-  z.lazy(() => GuardrailConfigBoolean$outboundSchema),
-  z.lazy(() => GuardrailConfigCategorical$outboundSchema),
-  z.lazy(() => GuardrailConfigNumber$outboundSchema),
-]);
-
-export function requestBodyGuardrailConfigToJSON(
-  requestBodyGuardrailConfig: RequestBodyGuardrailConfig,
-): string {
-  return JSON.stringify(
-    RequestBodyGuardrailConfig$outboundSchema.parse(requestBodyGuardrailConfig),
-  );
-}
-
-/** @internal */
-export const OutputType$outboundSchema: z.ZodNativeEnum<typeof OutputType> = z
-  .nativeEnum(OutputType);
-
-/** @internal */
-export const RequestBodyType$outboundSchema: z.ZodNativeEnum<
-  typeof RequestBodyType
-> = z.nativeEnum(RequestBodyType);
-
-/** @internal */
-export type Python$Outbound = {
-  guardrail_config?:
-    | GuardrailConfigBoolean$Outbound
-    | GuardrailConfigCategorical$Outbound
-    | GuardrailConfigNumber$Outbound
-    | null
-    | undefined;
-  output_type?: string | undefined;
-  code: string;
-  type: string;
-  path: string;
-  description: string;
-  key: string;
-};
-
-/** @internal */
-export const Python$outboundSchema: z.ZodType<
-  Python$Outbound,
-  z.ZodTypeDef,
-  Python
-> = z.object({
-  guardrailConfig: z.nullable(
-    z.union([
-      z.lazy(() => GuardrailConfigBoolean$outboundSchema),
-      z.lazy(() => GuardrailConfigCategorical$outboundSchema),
-      z.lazy(() => GuardrailConfigNumber$outboundSchema),
-    ]),
-  ).optional(),
-  outputType: OutputType$outboundSchema.optional(),
-  code: z.string(),
-  type: RequestBodyType$outboundSchema,
-  path: z.string(),
-  description: z.string().default(""),
-  key: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    guardrailConfig: "guardrail_config",
-    outputType: "output_type",
-  });
-});
-
-export function pythonToJSON(python: Python): string {
-  return JSON.stringify(Python$outboundSchema.parse(python));
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsRequestOperator$outboundSchema:
-  z.ZodNativeEnum<typeof CreateEvalGuardrailConfigEvalsRequestOperator> = z
-    .nativeEnum(CreateEvalGuardrailConfigEvalsRequestOperator);
-
-/** @internal */
-export type CreateEvalGuardrailConfigEvalsRequestNumber$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "number";
-  value: number;
-  operator: string;
-};
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsRequestNumber$outboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsRequestNumber$Outbound,
-    z.ZodTypeDef,
-    CreateEvalGuardrailConfigEvalsRequestNumber
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alertOnFailure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator: CreateEvalGuardrailConfigEvalsRequestOperator$outboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      alertOnFailure: "alert_on_failure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsRequestNumberToJSON(
-  createEvalGuardrailConfigEvalsRequestNumber:
-    CreateEvalGuardrailConfigEvalsRequestNumber,
-): string {
-  return JSON.stringify(
-    CreateEvalGuardrailConfigEvalsRequestNumber$outboundSchema.parse(
-      createEvalGuardrailConfigEvalsRequestNumber,
-    ),
-  );
-}
-
-/** @internal */
-export type CreateEvalGuardrailConfigEvalsRequestCategorical$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsRequestCategorical$outboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsRequestCategorical$Outbound,
-    z.ZodTypeDef,
-    CreateEvalGuardrailConfigEvalsRequestCategorical
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alertOnFailure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      alertOnFailure: "alert_on_failure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsRequestCategoricalToJSON(
-  createEvalGuardrailConfigEvalsRequestCategorical:
-    CreateEvalGuardrailConfigEvalsRequestCategorical,
-): string {
-  return JSON.stringify(
-    CreateEvalGuardrailConfigEvalsRequestCategorical$outboundSchema.parse(
-      createEvalGuardrailConfigEvalsRequestCategorical,
-    ),
-  );
-}
-
-/** @internal */
-export type CreateEvalGuardrailConfigEvalsRequestBoolean$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsRequestBoolean$outboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsRequestBoolean$Outbound,
-    z.ZodTypeDef,
-    CreateEvalGuardrailConfigEvalsRequestBoolean
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alertOnFailure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      alertOnFailure: "alert_on_failure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsRequestBooleanToJSON(
-  createEvalGuardrailConfigEvalsRequestBoolean:
-    CreateEvalGuardrailConfigEvalsRequestBoolean,
-): string {
-  return JSON.stringify(
-    CreateEvalGuardrailConfigEvalsRequestBoolean$outboundSchema.parse(
-      createEvalGuardrailConfigEvalsRequestBoolean,
-    ),
-  );
-}
-
-/** @internal */
-export type LLMGuardrailConfig$Outbound =
-  | CreateEvalGuardrailConfigEvalsRequestBoolean$Outbound
-  | CreateEvalGuardrailConfigEvalsRequestCategorical$Outbound
-  | CreateEvalGuardrailConfigEvalsRequestNumber$Outbound;
-
-/** @internal */
-export const LLMGuardrailConfig$outboundSchema: z.ZodType<
-  LLMGuardrailConfig$Outbound,
-  z.ZodTypeDef,
-  LLMGuardrailConfig
-> = z.union([
-  z.lazy(() => CreateEvalGuardrailConfigEvalsRequestBoolean$outboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigEvalsRequestCategorical$outboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigEvalsRequestNumber$outboundSchema),
-]);
-
-export function llmGuardrailConfigToJSON(
-  llmGuardrailConfig: LLMGuardrailConfig,
-): string {
-  return JSON.stringify(
-    LLMGuardrailConfig$outboundSchema.parse(llmGuardrailConfig),
-  );
-}
-
-/** @internal */
-export const LLMOutputType$outboundSchema: z.ZodNativeEnum<
-  typeof LLMOutputType
-> = z.nativeEnum(LLMOutputType);
-
-/** @internal */
-export const LLMType$outboundSchema: z.ZodNativeEnum<typeof LLMType> = z
-  .nativeEnum(LLMType);
-
-/** @internal */
-export type LLMCategoricalLabels$Outbound = {
-  value: string;
-  description?: string | undefined;
-};
-
-/** @internal */
-export const LLMCategoricalLabels$outboundSchema: z.ZodType<
-  LLMCategoricalLabels$Outbound,
-  z.ZodTypeDef,
-  LLMCategoricalLabels
-> = z.object({
-  value: z.string(),
-  description: z.string().optional(),
-});
-
-export function llmCategoricalLabelsToJSON(
-  llmCategoricalLabels: LLMCategoricalLabels,
-): string {
-  return JSON.stringify(
-    LLMCategoricalLabels$outboundSchema.parse(llmCategoricalLabels),
-  );
-}
-
-/** @internal */
-export type CreateEvalLLMRetry$Outbound = {
-  count: number;
-  on_codes?: Array<number> | undefined;
-};
-
-/** @internal */
-export const CreateEvalLLMRetry$outboundSchema: z.ZodType<
-  CreateEvalLLMRetry$Outbound,
-  z.ZodTypeDef,
-  CreateEvalLLMRetry
-> = z.object({
-  count: z.number().int().default(2),
-  onCodes: z.array(z.number().int()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    onCodes: "on_codes",
-  });
-});
-
-export function createEvalLLMRetryToJSON(
-  createEvalLLMRetry: CreateEvalLLMRetry,
-): string {
-  return JSON.stringify(
-    CreateEvalLLMRetry$outboundSchema.parse(createEvalLLMRetry),
-  );
-}
-
-/** @internal */
-export type CreateEvalLLMFallbacks$Outbound = {
-  model: string;
-};
-
-/** @internal */
-export const CreateEvalLLMFallbacks$outboundSchema: z.ZodType<
-  CreateEvalLLMFallbacks$Outbound,
-  z.ZodTypeDef,
-  CreateEvalLLMFallbacks
-> = z.object({
-  model: z.string(),
-});
-
-export function createEvalLLMFallbacksToJSON(
-  createEvalLLMFallbacks: CreateEvalLLMFallbacks,
-): string {
-  return JSON.stringify(
-    CreateEvalLLMFallbacks$outboundSchema.parse(createEvalLLMFallbacks),
-  );
-}
-
-/** @internal */
-export type LLMJudges$Outbound = {
-  model: string;
-  retry?: CreateEvalLLMRetry$Outbound | undefined;
-  fallbacks?: Array<CreateEvalLLMFallbacks$Outbound> | undefined;
-};
-
-/** @internal */
-export const LLMJudges$outboundSchema: z.ZodType<
-  LLMJudges$Outbound,
-  z.ZodTypeDef,
-  LLMJudges
-> = z.object({
-  model: z.string(),
-  retry: z.lazy(() => CreateEvalLLMRetry$outboundSchema).optional(),
-  fallbacks: z.array(z.lazy(() => CreateEvalLLMFallbacks$outboundSchema))
-    .optional(),
-});
-
-export function llmJudgesToJSON(llmJudges: LLMJudges): string {
-  return JSON.stringify(LLMJudges$outboundSchema.parse(llmJudges));
-}
-
-/** @internal */
-export type LLMRetry$Outbound = {
-  count: number;
-  on_codes?: Array<number> | undefined;
-};
-
-/** @internal */
-export const LLMRetry$outboundSchema: z.ZodType<
-  LLMRetry$Outbound,
-  z.ZodTypeDef,
-  LLMRetry
-> = z.object({
-  count: z.number().int().default(2),
-  onCodes: z.array(z.number().int()).optional(),
-}).transform((v) => {
-  return remap$(v, {
-    onCodes: "on_codes",
-  });
-});
-
-export function llmRetryToJSON(llmRetry: LLMRetry): string {
-  return JSON.stringify(LLMRetry$outboundSchema.parse(llmRetry));
-}
-
-/** @internal */
-export type LLMFallbacks$Outbound = {
-  model: string;
-};
-
-/** @internal */
-export const LLMFallbacks$outboundSchema: z.ZodType<
-  LLMFallbacks$Outbound,
-  z.ZodTypeDef,
-  LLMFallbacks
-> = z.object({
-  model: z.string(),
-});
-
-export function llmFallbacksToJSON(llmFallbacks: LLMFallbacks): string {
-  return JSON.stringify(LLMFallbacks$outboundSchema.parse(llmFallbacks));
-}
-
-/** @internal */
-export type LLMReplacementJudges$Outbound = {
-  model: string;
-  retry?: LLMRetry$Outbound | undefined;
-  fallbacks?: Array<LLMFallbacks$Outbound> | undefined;
-};
-
-/** @internal */
-export const LLMReplacementJudges$outboundSchema: z.ZodType<
-  LLMReplacementJudges$Outbound,
-  z.ZodTypeDef,
-  LLMReplacementJudges
-> = z.object({
-  model: z.string(),
-  retry: z.lazy(() => LLMRetry$outboundSchema).optional(),
-  fallbacks: z.array(z.lazy(() => LLMFallbacks$outboundSchema)).optional(),
-});
-
-export function llmReplacementJudgesToJSON(
-  llmReplacementJudges: LLMReplacementJudges,
-): string {
-  return JSON.stringify(
-    LLMReplacementJudges$outboundSchema.parse(llmReplacementJudges),
-  );
-}
-
-/** @internal */
-export const LLMTieValue$outboundSchema: z.ZodNativeEnum<typeof LLMTieValue> = z
-  .nativeEnum(LLMTieValue);
-
-/** @internal */
-export type LLMJury$Outbound = {
-  judges: Array<LLMJudges$Outbound>;
-  replacement_judges?: Array<LLMReplacementJudges$Outbound> | undefined;
-  min_successful_judges: number;
-  tie_value: string;
-};
-
-/** @internal */
-export const LLMJury$outboundSchema: z.ZodType<
-  LLMJury$Outbound,
-  z.ZodTypeDef,
-  LLMJury
-> = z.object({
-  judges: z.array(z.lazy(() => LLMJudges$outboundSchema)),
-  replacementJudges: z.array(z.lazy(() => LLMReplacementJudges$outboundSchema))
-    .optional(),
-  minSuccessfulJudges: z.number().int().default(2),
-  tieValue: LLMTieValue$outboundSchema.default("Tie"),
-}).transform((v) => {
-  return remap$(v, {
-    replacementJudges: "replacement_judges",
-    minSuccessfulJudges: "min_successful_judges",
-    tieValue: "tie_value",
-  });
-});
-
-export function llmJuryToJSON(llmJury: LLMJury): string {
-  return JSON.stringify(LLMJury$outboundSchema.parse(llmJury));
-}
-
-/** @internal */
-export type Llm2$Outbound = {
-  guardrail_config?:
-    | CreateEvalGuardrailConfigEvalsRequestBoolean$Outbound
-    | CreateEvalGuardrailConfigEvalsRequestCategorical$Outbound
-    | CreateEvalGuardrailConfigEvalsRequestNumber$Outbound
-    | null
-    | undefined;
-  output_type?: string | undefined;
-  type: string;
-  repetitions?: number | null | undefined;
-  prompt: string;
-  categories?: Array<string> | null | undefined;
-  categorical_labels?: Array<LLMCategoricalLabels$Outbound> | null | undefined;
-  dataset_id?: string | undefined;
-  path: string;
-  description: string;
-  key: string;
-  mode: "jury";
-  jury: LLMJury$Outbound;
-};
-
-/** @internal */
-export const Llm2$outboundSchema: z.ZodType<Llm2$Outbound, z.ZodTypeDef, Llm2> =
-  z.object({
-    guardrailConfig: z.nullable(
-      z.union([
-        z.lazy(() =>
-          CreateEvalGuardrailConfigEvalsRequestBoolean$outboundSchema
-        ),
-        z.lazy(() =>
-          CreateEvalGuardrailConfigEvalsRequestCategorical$outboundSchema
-        ),
-        z.lazy(() =>
-          CreateEvalGuardrailConfigEvalsRequestNumber$outboundSchema
-        ),
-      ]),
-    ).optional(),
-    outputType: LLMOutputType$outboundSchema.optional(),
-    type: LLMType$outboundSchema,
-    repetitions: z.nullable(z.number().int()).optional(),
-    prompt: z.string(),
-    categories: z.nullable(z.array(z.string())).optional(),
-    categoricalLabels: z.nullable(
-      z.array(z.lazy(() => LLMCategoricalLabels$outboundSchema)),
-    ).optional(),
-    datasetId: z.string().optional(),
-    path: z.string(),
-    description: z.string().default(""),
-    key: z.string(),
-    mode: z.literal("jury"),
-    jury: z.lazy(() => LLMJury$outboundSchema),
-  }).transform((v) => {
-    return remap$(v, {
-      guardrailConfig: "guardrail_config",
-      outputType: "output_type",
-      categoricalLabels: "categorical_labels",
-      datasetId: "dataset_id",
-    });
-  });
-
-export function llm2ToJSON(llm2: Llm2): string {
-  return JSON.stringify(Llm2$outboundSchema.parse(llm2));
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigOperator$outboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalGuardrailConfigOperator
-> = z.nativeEnum(CreateEvalGuardrailConfigOperator);
-
-/** @internal */
-export type CreateEvalGuardrailConfigNumber$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "number";
-  value: number;
-  operator: string;
-};
-
-/** @internal */
-export const CreateEvalGuardrailConfigNumber$outboundSchema: z.ZodType<
-  CreateEvalGuardrailConfigNumber$Outbound,
-  z.ZodTypeDef,
-  CreateEvalGuardrailConfigNumber
-> = z.object({
-  enabled: z.boolean().default(true),
-  alertOnFailure: z.boolean().default(false),
-  type: z.literal("number"),
-  value: z.number(),
-  operator: CreateEvalGuardrailConfigOperator$outboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    alertOnFailure: "alert_on_failure",
-  });
-});
-
-export function createEvalGuardrailConfigNumberToJSON(
-  createEvalGuardrailConfigNumber: CreateEvalGuardrailConfigNumber,
-): string {
-  return JSON.stringify(
-    CreateEvalGuardrailConfigNumber$outboundSchema.parse(
-      createEvalGuardrailConfigNumber,
-    ),
-  );
-}
-
-/** @internal */
-export type CreateEvalGuardrailConfigCategorical$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-/** @internal */
-export const CreateEvalGuardrailConfigCategorical$outboundSchema: z.ZodType<
-  CreateEvalGuardrailConfigCategorical$Outbound,
-  z.ZodTypeDef,
-  CreateEvalGuardrailConfigCategorical
-> = z.object({
-  enabled: z.boolean().default(true),
-  alertOnFailure: z.boolean().default(false),
-  type: z.literal("categorical"),
-  values: z.array(z.string()),
-}).transform((v) => {
-  return remap$(v, {
-    alertOnFailure: "alert_on_failure",
-  });
-});
-
-export function createEvalGuardrailConfigCategoricalToJSON(
-  createEvalGuardrailConfigCategorical: CreateEvalGuardrailConfigCategorical,
-): string {
-  return JSON.stringify(
-    CreateEvalGuardrailConfigCategorical$outboundSchema.parse(
-      createEvalGuardrailConfigCategorical,
-    ),
-  );
-}
-
-/** @internal */
-export type CreateEvalGuardrailConfigBoolean$Outbound = {
-  enabled: boolean;
-  alert_on_failure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-/** @internal */
-export const CreateEvalGuardrailConfigBoolean$outboundSchema: z.ZodType<
-  CreateEvalGuardrailConfigBoolean$Outbound,
-  z.ZodTypeDef,
-  CreateEvalGuardrailConfigBoolean
-> = z.object({
-  enabled: z.boolean().default(true),
-  alertOnFailure: z.boolean().default(false),
-  type: z.literal("boolean"),
-  value: z.boolean(),
-}).transform((v) => {
-  return remap$(v, {
-    alertOnFailure: "alert_on_failure",
-  });
-});
-
-export function createEvalGuardrailConfigBooleanToJSON(
-  createEvalGuardrailConfigBoolean: CreateEvalGuardrailConfigBoolean,
-): string {
-  return JSON.stringify(
-    CreateEvalGuardrailConfigBoolean$outboundSchema.parse(
-      createEvalGuardrailConfigBoolean,
-    ),
-  );
-}
-
-/** @internal */
-export type CreateEvalLLMGuardrailConfig$Outbound =
-  | CreateEvalGuardrailConfigBoolean$Outbound
-  | CreateEvalGuardrailConfigCategorical$Outbound
-  | CreateEvalGuardrailConfigNumber$Outbound;
-
-/** @internal */
-export const CreateEvalLLMGuardrailConfig$outboundSchema: z.ZodType<
-  CreateEvalLLMGuardrailConfig$Outbound,
-  z.ZodTypeDef,
-  CreateEvalLLMGuardrailConfig
-> = z.union([
-  z.lazy(() => CreateEvalGuardrailConfigBoolean$outboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigCategorical$outboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigNumber$outboundSchema),
-]);
-
-export function createEvalLLMGuardrailConfigToJSON(
-  createEvalLLMGuardrailConfig: CreateEvalLLMGuardrailConfig,
-): string {
-  return JSON.stringify(
-    CreateEvalLLMGuardrailConfig$outboundSchema.parse(
-      createEvalLLMGuardrailConfig,
-    ),
-  );
-}
-
-/** @internal */
-export const CreateEvalLLMOutputType$outboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalLLMOutputType
-> = z.nativeEnum(CreateEvalLLMOutputType);
-
-/** @internal */
-export const CreateEvalLLMType$outboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalLLMType
-> = z.nativeEnum(CreateEvalLLMType);
-
-/** @internal */
-export type CreateEvalLLMCategoricalLabels$Outbound = {
-  value: string;
-  description?: string | undefined;
-};
-
-/** @internal */
-export const CreateEvalLLMCategoricalLabels$outboundSchema: z.ZodType<
-  CreateEvalLLMCategoricalLabels$Outbound,
-  z.ZodTypeDef,
-  CreateEvalLLMCategoricalLabels
-> = z.object({
-  value: z.string(),
-  description: z.string().optional(),
-});
-
-export function createEvalLLMCategoricalLabelsToJSON(
-  createEvalLLMCategoricalLabels: CreateEvalLLMCategoricalLabels,
-): string {
-  return JSON.stringify(
-    CreateEvalLLMCategoricalLabels$outboundSchema.parse(
-      createEvalLLMCategoricalLabels,
-    ),
-  );
-}
-
-/** @internal */
-export type Llm1$Outbound = {
-  guardrail_config?:
-    | CreateEvalGuardrailConfigBoolean$Outbound
-    | CreateEvalGuardrailConfigCategorical$Outbound
-    | CreateEvalGuardrailConfigNumber$Outbound
-    | null
-    | undefined;
-  output_type?: string | undefined;
-  type: string;
-  repetitions?: number | null | undefined;
-  prompt: string;
-  categories?: Array<string> | null | undefined;
-  categorical_labels?:
-    | Array<CreateEvalLLMCategoricalLabels$Outbound>
-    | null
-    | undefined;
-  dataset_id?: string | undefined;
-  path: string;
-  description: string;
-  key: string;
-  mode: "single";
-  model: string;
-};
-
-/** @internal */
-export const Llm1$outboundSchema: z.ZodType<Llm1$Outbound, z.ZodTypeDef, Llm1> =
-  z.object({
-    guardrailConfig: z.nullable(
-      z.union([
-        z.lazy(() => CreateEvalGuardrailConfigBoolean$outboundSchema),
-        z.lazy(() => CreateEvalGuardrailConfigCategorical$outboundSchema),
-        z.lazy(() => CreateEvalGuardrailConfigNumber$outboundSchema),
-      ]),
-    ).optional(),
-    outputType: CreateEvalLLMOutputType$outboundSchema.optional(),
-    type: CreateEvalLLMType$outboundSchema,
-    repetitions: z.nullable(z.number().int()).optional(),
-    prompt: z.string(),
-    categories: z.nullable(z.array(z.string())).optional(),
-    categoricalLabels: z.nullable(
-      z.array(z.lazy(() => CreateEvalLLMCategoricalLabels$outboundSchema)),
-    ).optional(),
-    datasetId: z.string().optional(),
-    path: z.string(),
-    description: z.string().default(""),
-    key: z.string(),
-    mode: z.literal("single"),
-    model: z.string(),
-  }).transform((v) => {
-    return remap$(v, {
-      guardrailConfig: "guardrail_config",
-      outputType: "output_type",
-      categoricalLabels: "categorical_labels",
-      datasetId: "dataset_id",
-    });
-  });
-
-export function llm1ToJSON(llm1: Llm1): string {
-  return JSON.stringify(Llm1$outboundSchema.parse(llm1));
-}
-
-/** @internal */
-export type Llm$Outbound = Llm1$Outbound | Llm2$Outbound;
-
-/** @internal */
-export const Llm$outboundSchema: z.ZodType<Llm$Outbound, z.ZodTypeDef, Llm> = z
-  .union([
-    z.lazy(() => Llm1$outboundSchema),
-    z.lazy(() => Llm2$outboundSchema),
-  ]);
-
-export function llmToJSON(llm: Llm): string {
-  return JSON.stringify(Llm$outboundSchema.parse(llm));
-}
-
-/** @internal */
-export type CreateEvalRequestBody$Outbound =
-  | Python$Outbound
-  | Llm1$Outbound
-  | Llm2$Outbound;
-
-/** @internal */
-export const CreateEvalRequestBody$outboundSchema: z.ZodType<
-  CreateEvalRequestBody$Outbound,
-  z.ZodTypeDef,
-  CreateEvalRequestBody
-> = z.union([
-  z.lazy(() => Python$outboundSchema),
-  z.union([
-    z.lazy(() => Llm1$outboundSchema),
-    z.lazy(() => Llm2$outboundSchema),
-  ]),
-]);
-
-export function createEvalRequestBodyToJSON(
-  createEvalRequestBody: CreateEvalRequestBody,
-): string {
-  return JSON.stringify(
-    CreateEvalRequestBody$outboundSchema.parse(createEvalRequestBody),
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator$inboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator
-  > = z.nativeEnum(
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator,
-  );
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Operator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7NumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7CategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7BooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfig$inboundSchema:
-  z.ZodType<
-    CreateEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfig,
-    z.ZodTypeDef,
-    unknown
-  > = z.union([
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean$inboundSchema
-    ),
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical$inboundSchema
-    ),
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number$inboundSchema
-    ),
-  ]);
-
-export function createEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfig$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalResponseBodyEvalsResponse200ApplicationJSONGuardrailConfig' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsResponse200ApplicationJSONType$inboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateEvalResponseBodyEvalsResponse200ApplicationJSONType
-  > = z.nativeEnum(CreateEvalResponseBodyEvalsResponse200ApplicationJSONType);
-
-/** @internal */
-export const Typescript$inboundSchema: z.ZodType<
-  Typescript,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  _id: z.string(),
-  description: z.string(),
-  created: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Boolean$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Categorical$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody7Number$inboundSchema
-      ),
-    ]),
-  ).optional(),
-  code: z.string(),
-  type: CreateEvalResponseBodyEvalsResponse200ApplicationJSONType$inboundSchema,
-  key: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "_id": "id",
-    "updated_by_id": "updatedById",
-    "guardrail_config": "guardrailConfig",
-  });
-});
-
-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 CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator$inboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator
-  > = z.nativeEnum(
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator,
-  );
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsResponse200GuardrailConfig$inboundSchema:
-  z.ZodType<
-    CreateEvalResponseBodyEvalsResponse200GuardrailConfig,
-    z.ZodTypeDef,
-    unknown
-  > = z.union([
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema
-    ),
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical$inboundSchema
-    ),
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema
-    ),
-  ]);
-
-export function createEvalResponseBodyEvalsResponse200GuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalResponseBodyEvalsResponse200GuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalResponseBodyEvalsResponse200GuardrailConfig$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalResponseBodyEvalsResponse200GuardrailConfig' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsResponse200Type$inboundSchema:
-  z.ZodNativeEnum<typeof CreateEvalResponseBodyEvalsResponse200Type> = z
-    .nativeEnum(CreateEvalResponseBodyEvalsResponse200Type);
-
-/** @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({
-    _id: z.string(),
-    description: z.string(),
-    created: z.string().default("2026-06-29T06:24:58.448Z"),
-    updated: z.string().default("2026-06-29T06:24:58.448Z"),
-    updated_by_id: z.nullable(z.string()).optional(),
-    guardrail_config: z.nullable(
-      z.union([
-        z.lazy(() =>
-          CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyBoolean$inboundSchema
-        ),
-        z.lazy(() =>
-          CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyCategorical$inboundSchema
-        ),
-        z.lazy(() =>
-          CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBodyNumber$inboundSchema
-        ),
-      ]),
-    ).optional(),
-    type: CreateEvalResponseBodyEvalsResponse200Type$inboundSchema,
-    ragas_metric: RagasMetric$inboundSchema,
-    key: z.string(),
-    model: z.string(),
-  }).transform((v) => {
-    return remap$(v, {
-      "_id": "id",
-      "updated_by_id": "updatedById",
-      "guardrail_config": "guardrailConfig",
-      "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 CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator$inboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator
-  > = z.nativeEnum(
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator,
-  );
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsResponseGuardrailConfig$inboundSchema:
-  z.ZodType<
-    CreateEvalResponseBodyEvalsResponseGuardrailConfig,
-    z.ZodTypeDef,
-    unknown
-  > = z.union([
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema
-    ),
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical$inboundSchema
-    ),
-    z.lazy(() =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema
-    ),
-  ]);
-
-export function createEvalResponseBodyEvalsResponseGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalResponseBodyEvalsResponseGuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalResponseBodyEvalsResponseGuardrailConfig$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalResponseBodyEvalsResponseGuardrailConfig' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsResponseType$inboundSchema:
-  z.ZodNativeEnum<typeof CreateEvalResponseBodyEvalsResponseType> = z
-    .nativeEnum(CreateEvalResponseBodyEvalsResponseType);
-
-/** @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 Six$inboundSchema: z.ZodType<Six, z.ZodTypeDef, unknown> = z
-  .object({
-    type: z.literal("contains_url"),
-  });
-
-export function sixFromJSON(
-  jsonString: string,
-): SafeParseResult<Six, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Six$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Six' from JSON`,
-  );
-}
-
-/** @internal */
-export const Five$inboundSchema: z.ZodType<Five, z.ZodTypeDef, unknown> = z
-  .object({
-    type: z.literal("contains_email"),
-  });
-
-export function fiveFromJSON(
-  jsonString: string,
-): SafeParseResult<Five, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Five$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Five' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalFunctionParams4$inboundSchema: z.ZodType<
-  CreateEvalFunctionParams4,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: z.literal("contains_any"),
-  keywords: z.array(z.string()),
-});
-
-export function createEvalFunctionParams4FromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalFunctionParams4, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalFunctionParams4$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalFunctionParams4' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalFunctionParams3$inboundSchema: z.ZodType<
-  CreateEvalFunctionParams3,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  type: z.literal("contains_all"),
-  keywords: z.array(z.string()),
-});
-
-export function createEvalFunctionParams3FromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalFunctionParams3, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalFunctionParams3$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalFunctionParams3' 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(() => CreateEvalFunctionParams3$inboundSchema),
-  z.lazy(() => CreateEvalFunctionParams4$inboundSchema),
-  z.lazy(() => Five$inboundSchema),
-  z.lazy(() => Six$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 CreateEvalResponseBodyFunction$inboundSchema: z.ZodType<
-  CreateEvalResponseBodyFunction,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  _id: z.string(),
-  description: z.string(),
-  created: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONBoolean$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONCategorical$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONNumber$inboundSchema
-      ),
-    ]),
-  ).optional(),
-  type: CreateEvalResponseBodyEvalsResponseType$inboundSchema,
-  function_params: z.union([
-    z.lazy(() => FunctionParams1$inboundSchema),
-    z.lazy(() => FunctionParams2$inboundSchema),
-    z.lazy(() => CreateEvalFunctionParams3$inboundSchema),
-    z.lazy(() => CreateEvalFunctionParams4$inboundSchema),
-    z.lazy(() => Five$inboundSchema),
-    z.lazy(() => Six$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),
-  ]),
-  key: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "_id": "id",
-    "updated_by_id": "updatedById",
-    "guardrail_config": "guardrailConfig",
-    "function_params": "functionParams",
-  });
-});
-
-export function createEvalResponseBodyFunctionFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalResponseBodyFunction, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalResponseBodyFunction$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalResponseBodyFunction' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200Operator$inboundSchema:
-  z.ZodNativeEnum<typeof CreateEvalGuardrailConfigEvalsResponse200Operator> = z
-    .nativeEnum(CreateEvalGuardrailConfigEvalsResponse200Operator);
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200Number$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200Number,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator: CreateEvalGuardrailConfigEvalsResponse200Operator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200NumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200Number,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200Number$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200Number' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200Categorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200Categorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200CategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200Categorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200Categorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200Categorical' from JSON`,
-  );
-}
-
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200Boolean$inboundSchema:
+export const CreateEvalGuardrailConfigEvalsCategorical$outboundSchema:
   z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200Boolean,
+    CreateEvalGuardrailConfigEvalsCategorical$Outbound,
     z.ZodTypeDef,
-    unknown
+    CreateEvalGuardrailConfigEvalsCategorical
   > = z.object({
     enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
+    alertOnFailure: z.boolean().default(false),
+    type: z.literal("categorical"),
+    values: z.array(z.string()),
   }).transform((v) => {
     return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
+      alertOnFailure: "alert_on_failure",
     });
   });
 
-export function createEvalGuardrailConfigEvalsResponse200BooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200Boolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200Boolean$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200Boolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalResponseBodyEvalsGuardrailConfig$inboundSchema:
-  z.ZodType<CreateEvalResponseBodyEvalsGuardrailConfig, z.ZodTypeDef, unknown> =
-    z.union([
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200Boolean$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200Categorical$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200Number$inboundSchema
-      ),
-    ]);
-
-export function createEvalResponseBodyEvalsGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalResponseBodyEvalsGuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalResponseBodyEvalsGuardrailConfig$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalResponseBodyEvalsGuardrailConfig' from JSON`,
+export function createEvalGuardrailConfigEvalsCategoricalToJSON(
+  createEvalGuardrailConfigEvalsCategorical:
+    CreateEvalGuardrailConfigEvalsCategorical,
+): string {
+  return JSON.stringify(
+    CreateEvalGuardrailConfigEvalsCategorical$outboundSchema.parse(
+      createEvalGuardrailConfigEvalsCategorical,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalResponseBodyEvalsType$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalResponseBodyEvalsType
-> = z.nativeEnum(CreateEvalResponseBodyEvalsType);
+export type CreateEvalGuardrailConfigEvalsBoolean$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "boolean";
+  value: boolean;
+};
 
 /** @internal */
-export const ResponseBodyPython$inboundSchema: z.ZodType<
-  ResponseBodyPython,
+export const CreateEvalGuardrailConfigEvalsBoolean$outboundSchema: z.ZodType<
+  CreateEvalGuardrailConfigEvalsBoolean$Outbound,
   z.ZodTypeDef,
-  unknown
+  CreateEvalGuardrailConfigEvalsBoolean
 > = z.object({
-  _id: z.string(),
-  description: z.string(),
-  created: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200Boolean$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200Categorical$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200Number$inboundSchema
-      ),
-    ]),
-  ).optional(),
-  code: z.string(),
-  type: CreateEvalResponseBodyEvalsType$inboundSchema,
-  key: z.string(),
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("boolean"),
+  value: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
-    "_id": "id",
-    "updated_by_id": "updatedById",
-    "guardrail_config": "guardrailConfig",
+    alertOnFailure: "alert_on_failure",
   });
 });
 
-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 CreateEvalGuardrailConfigEvalsResponseOperator$inboundSchema:
-  z.ZodNativeEnum<typeof CreateEvalGuardrailConfigEvalsResponseOperator> = z
-    .nativeEnum(CreateEvalGuardrailConfigEvalsResponseOperator);
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponseNumber$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponseNumber,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator: CreateEvalGuardrailConfigEvalsResponseOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponseNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponseNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponseNumber$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponseNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponseCategorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponseCategorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponseCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponseCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponseCategorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponseCategorical' from JSON`,
+export function createEvalGuardrailConfigEvalsBooleanToJSON(
+  createEvalGuardrailConfigEvalsBoolean: CreateEvalGuardrailConfigEvalsBoolean,
+): string {
+  return JSON.stringify(
+    CreateEvalGuardrailConfigEvalsBoolean$outboundSchema.parse(
+      createEvalGuardrailConfigEvalsBoolean,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponseBoolean,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponseBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponseBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponseBoolean' from JSON`,
-  );
-}
+export type LLMGuardrailConfig$Outbound =
+  | CreateEvalGuardrailConfigEvalsBoolean$Outbound
+  | CreateEvalGuardrailConfigEvalsCategorical$Outbound
+  | CreateEvalGuardrailConfigEvalsNumber$Outbound;
 
 /** @internal */
-export const CreateEvalResponseBodyGuardrailConfig$inboundSchema: z.ZodType<
-  CreateEvalResponseBodyGuardrailConfig,
+export const LLMGuardrailConfig$outboundSchema: z.ZodType<
+  LLMGuardrailConfig$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMGuardrailConfig
 > = z.union([
-  z.lazy(() => CreateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigEvalsResponseCategorical$inboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigEvalsResponseNumber$inboundSchema),
+  z.lazy(() => CreateEvalGuardrailConfigEvalsBoolean$outboundSchema),
+  z.lazy(() => CreateEvalGuardrailConfigEvalsCategorical$outboundSchema),
+  z.lazy(() => CreateEvalGuardrailConfigEvalsNumber$outboundSchema),
 ]);
 
-export function createEvalResponseBodyGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalResponseBodyGuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalResponseBodyGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalResponseBodyGuardrailConfig' from JSON`,
+export function llmGuardrailConfigToJSON(
+  llmGuardrailConfig: LLMGuardrailConfig,
+): string {
+  return JSON.stringify(
+    LLMGuardrailConfig$outboundSchema.parse(llmGuardrailConfig),
   );
 }
 
 /** @internal */
-export const CreateEvalResponseBodyType$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalResponseBodyType
-> = z.nativeEnum(CreateEvalResponseBodyType);
-
-/** @internal */
-export const CreateEvalResponseBodyMethod$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalResponseBodyMethod
-> = z.nativeEnum(CreateEvalResponseBodyMethod);
+export const LLMOutputType$outboundSchema: z.ZodNativeEnum<
+  typeof LLMOutputType
+> = z.nativeEnum(LLMOutputType);
 
 /** @internal */
-export const CreateEvalResponseBodyHTTP$inboundSchema: z.ZodType<
-  CreateEvalResponseBodyHTTP,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  _id: z.string(),
-  description: z.string(),
-  created: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() => CreateEvalGuardrailConfigEvalsResponseBoolean$inboundSchema),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponseCategorical$inboundSchema
-      ),
-      z.lazy(() => CreateEvalGuardrailConfigEvalsResponseNumber$inboundSchema),
-    ]),
-  ).optional(),
-  type: CreateEvalResponseBodyType$inboundSchema,
-  url: z.string(),
-  method: CreateEvalResponseBodyMethod$inboundSchema,
-  headers: z.record(z.string()),
-  payload: z.record(z.any()),
-  key: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "_id": "id",
-    "updated_by_id": "updatedById",
-    "guardrail_config": "guardrailConfig",
-  });
-});
-
-export function createEvalResponseBodyHTTPFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalResponseBodyHTTP, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalResponseBodyHTTP$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalResponseBodyHTTP' from JSON`,
-  );
-}
+export const LLMType$outboundSchema: z.ZodNativeEnum<typeof LLMType> = z
+  .nativeEnum(LLMType);
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsOperator$inboundSchema:
-  z.ZodNativeEnum<typeof CreateEvalGuardrailConfigEvalsOperator> = z.nativeEnum(
-    CreateEvalGuardrailConfigEvalsOperator,
-  );
+export type LLMCategoricalLabels$Outbound = {
+  value: string;
+  description?: string | undefined;
+};
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsNumber$inboundSchema: z.ZodType<
-  CreateEvalGuardrailConfigEvalsNumber,
+export const LLMCategoricalLabels$outboundSchema: z.ZodType<
+  LLMCategoricalLabels$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMCategoricalLabels
 > = z.object({
-  enabled: z.boolean().default(true),
-  alert_on_failure: z.boolean().default(false),
-  type: z.literal("number"),
-  value: z.number(),
-  operator: CreateEvalGuardrailConfigEvalsOperator$inboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    "alert_on_failure": "alertOnFailure",
-  });
+  value: z.string(),
+  description: z.string().optional(),
 });
 
-export function createEvalGuardrailConfigEvalsNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalGuardrailConfigEvalsNumber, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsNumber$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsNumber' from JSON`,
+export function llmCategoricalLabelsToJSON(
+  llmCategoricalLabels: LLMCategoricalLabels,
+): string {
+  return JSON.stringify(
+    LLMCategoricalLabels$outboundSchema.parse(llmCategoricalLabels),
   );
 }
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsCategorical$inboundSchema: z.ZodType<
-  CreateEvalGuardrailConfigEvalsCategorical,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  enabled: z.boolean().default(true),
-  alert_on_failure: z.boolean().default(false),
-  type: z.literal("categorical"),
-  values: z.array(z.string()),
-}).transform((v) => {
-  return remap$(v, {
-    "alert_on_failure": "alertOnFailure",
-  });
-});
-
-export function createEvalGuardrailConfigEvalsCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsCategorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsCategorical' from JSON`,
-  );
-}
+export type CreateEvalLLMRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsBoolean$inboundSchema: z.ZodType<
-  CreateEvalGuardrailConfigEvalsBoolean,
+export const CreateEvalLLMRetry$outboundSchema: z.ZodType<
+  CreateEvalLLMRetry$Outbound,
   z.ZodTypeDef,
-  unknown
+  CreateEvalLLMRetry
 > = z.object({
-  enabled: z.boolean().default(true),
-  alert_on_failure: z.boolean().default(false),
-  type: z.literal("boolean"),
-  value: z.boolean(),
+  count: z.number().int().default(2),
+  onCodes: z.array(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    "alert_on_failure": "alertOnFailure",
-  });
-});
-
-export function createEvalGuardrailConfigEvalsBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalGuardrailConfigEvalsBoolean, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsBoolean$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponseBodyGuardrailConfig$inboundSchema: z.ZodType<
-  ResponseBodyGuardrailConfig,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => CreateEvalGuardrailConfigEvalsBoolean$inboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigEvalsCategorical$inboundSchema),
-  z.lazy(() => CreateEvalGuardrailConfigEvalsNumber$inboundSchema),
-]);
-
-export function responseBodyGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponseBodyGuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponseBodyGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseBodyGuardrailConfig' from JSON`,
-  );
-}
-
-/** @internal */
-export const ResponseBodyType$inboundSchema: z.ZodNativeEnum<
-  typeof ResponseBodyType
-> = z.nativeEnum(ResponseBodyType);
-
-/** @internal */
-export const Json$inboundSchema: z.ZodType<Json, z.ZodTypeDef, unknown> = z
-  .object({
-    _id: z.string(),
-    description: z.string(),
-    created: z.string().default("2026-06-29T06:24:58.448Z"),
-    updated: z.string().default("2026-06-29T06:24:58.448Z"),
-    updated_by_id: z.nullable(z.string()).optional(),
-    guardrail_config: z.nullable(
-      z.union([
-        z.lazy(() => CreateEvalGuardrailConfigEvalsBoolean$inboundSchema),
-        z.lazy(() => CreateEvalGuardrailConfigEvalsCategorical$inboundSchema),
-        z.lazy(() => CreateEvalGuardrailConfigEvalsNumber$inboundSchema),
-      ]),
-    ).optional(),
-    type: ResponseBodyType$inboundSchema,
-    schema: z.string(),
-    key: z.string(),
-  }).transform((v) => {
-    return remap$(v, {
-      "_id": "id",
-      "updated_by_id": "updatedById",
-      "guardrail_config": "guardrailConfig",
-    });
-  });
-
-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 CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator$inboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator
-  > = z.nativeEnum(
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator,
-  );
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Operator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1NumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number' from JSON`,
-  );
-}
-
-/** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
+    onCodes: "on_codes",
   });
+});
 
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1CategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical' from JSON`,
+export function createEvalLLMRetryToJSON(
+  createEvalLLMRetry: CreateEvalLLMRetry,
+): string {
+  return JSON.stringify(
+    CreateEvalLLMRetry$outboundSchema.parse(createEvalLLMRetry),
   );
 }
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1BooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean' from JSON`,
-  );
-}
+export type CreateEvalLLMFallbacks$Outbound = {
+  model: string;
+};
 
 /** @internal */
-export const CreateEvalLLMEvalsResponseGuardrailConfig$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsResponseGuardrailConfig,
+export const CreateEvalLLMFallbacks$outboundSchema: z.ZodType<
+  CreateEvalLLMFallbacks$Outbound,
   z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() =>
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean$inboundSchema
-  ),
-  z.lazy(() =>
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical$inboundSchema
-  ),
-  z.lazy(() =>
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number$inboundSchema
-  ),
-]);
+  CreateEvalLLMFallbacks
+> = z.object({
+  model: z.string(),
+});
 
-export function createEvalLLMEvalsResponseGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalLLMEvalsResponseGuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalLLMEvalsResponseGuardrailConfig$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalLLMEvalsResponseGuardrailConfig' from JSON`,
+export function createEvalLLMFallbacksToJSON(
+  createEvalLLMFallbacks: CreateEvalLLMFallbacks,
+): string {
+  return JSON.stringify(
+    CreateEvalLLMFallbacks$outboundSchema.parse(createEvalLLMFallbacks),
   );
 }
 
 /** @internal */
-export const CreateEvalLLMEvalsResponseType$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalLLMEvalsResponseType
-> = z.nativeEnum(CreateEvalLLMEvalsResponseType);
+export type LLMJudges$Outbound = {
+  model: string;
+  retry?: CreateEvalLLMRetry$Outbound | undefined;
+  fallbacks?: Array<CreateEvalLLMFallbacks$Outbound> | undefined;
+};
 
 /** @internal */
-export const CreateEvalLLMEvalsCategoricalLabels$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsCategoricalLabels,
+export const LLMJudges$outboundSchema: z.ZodType<
+  LLMJudges$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMJudges
 > = z.object({
-  value: z.string(),
-  description: z.string().optional(),
+  model: z.string(),
+  retry: z.lazy(() => CreateEvalLLMRetry$outboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => CreateEvalLLMFallbacks$outboundSchema))
+    .optional(),
 });
 
-export function createEvalLLMEvalsCategoricalLabelsFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMEvalsCategoricalLabels, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalLLMEvalsCategoricalLabels$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMEvalsCategoricalLabels' from JSON`,
-  );
+export function llmJudgesToJSON(llmJudges: LLMJudges): string {
+  return JSON.stringify(LLMJudges$outboundSchema.parse(llmJudges));
 }
 
 /** @internal */
-export const CreateEvalLLMEvalsResponseRetry$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsResponseRetry,
+export type LLMRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
+
+/** @internal */
+export const LLMRetry$outboundSchema: z.ZodType<
+  LLMRetry$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMRetry
 > = z.object({
   count: z.number().int().default(2),
-  on_codes: z.array(z.number().int()).optional(),
+  onCodes: z.array(z.number().int()).optional(),
 }).transform((v) => {
   return remap$(v, {
-    "on_codes": "onCodes",
+    onCodes: "on_codes",
   });
 });
 
-export function createEvalLLMEvalsResponseRetryFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMEvalsResponseRetry, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMEvalsResponseRetry$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMEvalsResponseRetry' from JSON`,
-  );
+export function llmRetryToJSON(llmRetry: LLMRetry): string {
+  return JSON.stringify(LLMRetry$outboundSchema.parse(llmRetry));
 }
 
 /** @internal */
-export const CreateEvalLLMEvalsResponseFallbacks$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsResponseFallbacks,
+export type LLMFallbacks$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const LLMFallbacks$outboundSchema: z.ZodType<
+  LLMFallbacks$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMFallbacks
 > = z.object({
   model: z.string(),
 });
 
-export function createEvalLLMEvalsResponseFallbacksFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMEvalsResponseFallbacks, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalLLMEvalsResponseFallbacks$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMEvalsResponseFallbacks' from JSON`,
-  );
+export function llmFallbacksToJSON(llmFallbacks: LLMFallbacks): string {
+  return JSON.stringify(LLMFallbacks$outboundSchema.parse(llmFallbacks));
 }
 
 /** @internal */
-export const CreateEvalLLMJudges$inboundSchema: z.ZodType<
-  CreateEvalLLMJudges,
+export type LLMReplacementJudges$Outbound = {
+  model: string;
+  retry?: LLMRetry$Outbound | undefined;
+  fallbacks?: Array<LLMFallbacks$Outbound> | undefined;
+};
+
+/** @internal */
+export const LLMReplacementJudges$outboundSchema: z.ZodType<
+  LLMReplacementJudges$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMReplacementJudges
 > = z.object({
   model: z.string(),
-  retry: z.lazy(() => CreateEvalLLMEvalsResponseRetry$inboundSchema).optional(),
-  fallbacks: z.array(
-    z.lazy(() => CreateEvalLLMEvalsResponseFallbacks$inboundSchema),
-  ).optional(),
+  retry: z.lazy(() => LLMRetry$outboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => LLMFallbacks$outboundSchema)).optional(),
 });
 
-export function createEvalLLMJudgesFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMJudges, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMJudges$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMJudges' from JSON`,
+export function llmReplacementJudgesToJSON(
+  llmReplacementJudges: LLMReplacementJudges,
+): string {
+  return JSON.stringify(
+    LLMReplacementJudges$outboundSchema.parse(llmReplacementJudges),
   );
 }
 
 /** @internal */
-export const CreateEvalLLMEvalsRetry$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsRetry,
+export const LLMTieValue$outboundSchema: z.ZodNativeEnum<typeof LLMTieValue> = z
+  .nativeEnum(LLMTieValue);
+
+/** @internal */
+export type LLMJury$Outbound = {
+  judges: Array<LLMJudges$Outbound>;
+  replacement_judges?: Array<LLMReplacementJudges$Outbound> | undefined;
+  min_successful_judges: number;
+  tie_value: string;
+};
+
+/** @internal */
+export const LLMJury$outboundSchema: z.ZodType<
+  LLMJury$Outbound,
   z.ZodTypeDef,
-  unknown
+  LLMJury
 > = z.object({
-  count: z.number().int().default(2),
-  on_codes: z.array(z.number().int()).optional(),
+  judges: z.array(z.lazy(() => LLMJudges$outboundSchema)),
+  replacementJudges: z.array(z.lazy(() => LLMReplacementJudges$outboundSchema))
+    .optional(),
+  minSuccessfulJudges: z.number().int().default(2),
+  tieValue: LLMTieValue$outboundSchema.default("Tie"),
 }).transform((v) => {
   return remap$(v, {
-    "on_codes": "onCodes",
+    replacementJudges: "replacement_judges",
+    minSuccessfulJudges: "min_successful_judges",
+    tieValue: "tie_value",
   });
 });
 
-export function createEvalLLMEvalsRetryFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMEvalsRetry, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMEvalsRetry$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMEvalsRetry' from JSON`,
-  );
+export function llmJuryToJSON(llmJury: LLMJury): string {
+  return JSON.stringify(LLMJury$outboundSchema.parse(llmJury));
 }
 
 /** @internal */
-export const CreateEvalLLMEvalsFallbacks$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsFallbacks,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  model: z.string(),
-});
+export type Llm2$Outbound = {
+  guardrail_config?:
+    | CreateEvalGuardrailConfigEvalsBoolean$Outbound
+    | CreateEvalGuardrailConfigEvalsCategorical$Outbound
+    | CreateEvalGuardrailConfigEvalsNumber$Outbound
+    | null
+    | undefined;
+  output_type?: string | undefined;
+  type: string;
+  repetitions?: number | null | undefined;
+  prompt: string;
+  categories?: Array<string> | null | undefined;
+  categorical_labels?: Array<LLMCategoricalLabels$Outbound> | null | undefined;
+  dataset_id?: string | undefined;
+  path: string;
+  description: string;
+  key: string;
+  mode: "jury";
+  jury: LLMJury$Outbound;
+};
 
-export function createEvalLLMEvalsFallbacksFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMEvalsFallbacks, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMEvalsFallbacks$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMEvalsFallbacks' from JSON`,
-  );
+/** @internal */
+export const Llm2$outboundSchema: z.ZodType<Llm2$Outbound, z.ZodTypeDef, Llm2> =
+  z.object({
+    guardrailConfig: z.nullable(
+      z.union([
+        z.lazy(() => CreateEvalGuardrailConfigEvalsBoolean$outboundSchema),
+        z.lazy(() => CreateEvalGuardrailConfigEvalsCategorical$outboundSchema),
+        z.lazy(() => CreateEvalGuardrailConfigEvalsNumber$outboundSchema),
+      ]),
+    ).optional(),
+    outputType: LLMOutputType$outboundSchema.optional(),
+    type: LLMType$outboundSchema,
+    repetitions: z.nullable(z.number().int()).optional(),
+    prompt: z.string(),
+    categories: z.nullable(z.array(z.string())).optional(),
+    categoricalLabels: z.nullable(
+      z.array(z.lazy(() => LLMCategoricalLabels$outboundSchema)),
+    ).optional(),
+    datasetId: z.string().optional(),
+    path: z.string(),
+    description: z.string().default(""),
+    key: z.string(),
+    mode: z.literal("jury"),
+    jury: z.lazy(() => LLMJury$outboundSchema),
+  }).transform((v) => {
+    return remap$(v, {
+      guardrailConfig: "guardrail_config",
+      outputType: "output_type",
+      categoricalLabels: "categorical_labels",
+      datasetId: "dataset_id",
+    });
+  });
+
+export function llm2ToJSON(llm2: Llm2): string {
+  return JSON.stringify(Llm2$outboundSchema.parse(llm2));
 }
 
 /** @internal */
-export const CreateEvalLLMReplacementJudges$inboundSchema: z.ZodType<
-  CreateEvalLLMReplacementJudges,
+export const CreateEvalGuardrailConfigOperator$outboundSchema: z.ZodNativeEnum<
+  typeof CreateEvalGuardrailConfigOperator
+> = z.nativeEnum(CreateEvalGuardrailConfigOperator);
+
+/** @internal */
+export type CreateEvalGuardrailConfigNumber$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "number";
+  value: number;
+  operator: string;
+};
+
+/** @internal */
+export const CreateEvalGuardrailConfigNumber$outboundSchema: z.ZodType<
+  CreateEvalGuardrailConfigNumber$Outbound,
   z.ZodTypeDef,
-  unknown
+  CreateEvalGuardrailConfigNumber
 > = z.object({
-  model: z.string(),
-  retry: z.lazy(() => CreateEvalLLMEvalsRetry$inboundSchema).optional(),
-  fallbacks: z.array(z.lazy(() => CreateEvalLLMEvalsFallbacks$inboundSchema))
-    .optional(),
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("number"),
+  value: z.number(),
+  operator: CreateEvalGuardrailConfigOperator$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    alertOnFailure: "alert_on_failure",
+  });
 });
 
-export function createEvalLLMReplacementJudgesFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMReplacementJudges, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMReplacementJudges$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMReplacementJudges' from JSON`,
+export function createEvalGuardrailConfigNumberToJSON(
+  createEvalGuardrailConfigNumber: CreateEvalGuardrailConfigNumber,
+): string {
+  return JSON.stringify(
+    CreateEvalGuardrailConfigNumber$outboundSchema.parse(
+      createEvalGuardrailConfigNumber,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalLLMTieValue$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalLLMTieValue
-> = z.nativeEnum(CreateEvalLLMTieValue);
+export type CreateEvalGuardrailConfigCategorical$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "categorical";
+  values: Array<string>;
+};
 
 /** @internal */
-export const CreateEvalLLMJury$inboundSchema: z.ZodType<
-  CreateEvalLLMJury,
+export const CreateEvalGuardrailConfigCategorical$outboundSchema: z.ZodType<
+  CreateEvalGuardrailConfigCategorical$Outbound,
   z.ZodTypeDef,
-  unknown
+  CreateEvalGuardrailConfigCategorical
 > = z.object({
-  judges: z.array(z.lazy(() => CreateEvalLLMJudges$inboundSchema)),
-  replacement_judges: z.array(
-    z.lazy(() => CreateEvalLLMReplacementJudges$inboundSchema),
-  ).optional(),
-  min_successful_judges: z.number().int().default(2),
-  tie_value: CreateEvalLLMTieValue$inboundSchema.default("Tie"),
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("categorical"),
+  values: z.array(z.string()),
 }).transform((v) => {
   return remap$(v, {
-    "replacement_judges": "replacementJudges",
-    "min_successful_judges": "minSuccessfulJudges",
-    "tie_value": "tieValue",
+    alertOnFailure: "alert_on_failure",
   });
 });
 
-export function createEvalLLMJuryFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMJury, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMJury$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMJury' from JSON`,
+export function createEvalGuardrailConfigCategoricalToJSON(
+  createEvalGuardrailConfigCategorical: CreateEvalGuardrailConfigCategorical,
+): string {
+  return JSON.stringify(
+    CreateEvalGuardrailConfigCategorical$outboundSchema.parse(
+      createEvalGuardrailConfigCategorical,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalLlm2$inboundSchema: z.ZodType<
-  CreateEvalLlm2,
+export type CreateEvalGuardrailConfigBoolean$Outbound = {
+  enabled: boolean;
+  alert_on_failure: boolean;
+  type: "boolean";
+  value: boolean;
+};
+
+/** @internal */
+export const CreateEvalGuardrailConfigBoolean$outboundSchema: z.ZodType<
+  CreateEvalGuardrailConfigBoolean$Outbound,
   z.ZodTypeDef,
-  unknown
+  CreateEvalGuardrailConfigBoolean
 > = z.object({
-  _id: z.string(),
-  description: z.string(),
-  created: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Boolean$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Categorical$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1Number$inboundSchema
-      ),
-    ]),
-  ).optional(),
-  type: CreateEvalLLMEvalsResponseType$inboundSchema,
-  repetitions: z.nullable(z.number().int()).optional(),
-  prompt: z.string(),
-  categories: z.nullable(z.array(z.string())).optional(),
-  categorical_labels: z.nullable(
-    z.array(z.lazy(() => CreateEvalLLMEvalsCategoricalLabels$inboundSchema)),
-  ).optional(),
-  dataset_id: z.string().optional(),
-  key: z.string(),
-  mode: z.literal("jury"),
-  jury: z.lazy(() => CreateEvalLLMJury$inboundSchema),
+  enabled: z.boolean().default(true),
+  alertOnFailure: z.boolean().default(false),
+  type: z.literal("boolean"),
+  value: z.boolean(),
 }).transform((v) => {
   return remap$(v, {
-    "_id": "id",
-    "updated_by_id": "updatedById",
-    "guardrail_config": "guardrailConfig",
-    "categorical_labels": "categoricalLabels",
-    "dataset_id": "datasetId",
+    alertOnFailure: "alert_on_failure",
   });
 });
 
-export function createEvalLLM2FromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLlm2, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLlm2$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLlm2' from JSON`,
+export function createEvalGuardrailConfigBooleanToJSON(
+  createEvalGuardrailConfigBoolean: CreateEvalGuardrailConfigBoolean,
+): string {
+  return JSON.stringify(
+    CreateEvalGuardrailConfigBoolean$outboundSchema.parse(
+      createEvalGuardrailConfigBoolean,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator$inboundSchema:
-  z.ZodNativeEnum<
-    typeof CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator
-  > = z.nativeEnum(
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator,
-  );
+export type CreateEvalLLMGuardrailConfig$Outbound =
+  | CreateEvalGuardrailConfigBoolean$Outbound
+  | CreateEvalGuardrailConfigCategorical$Outbound
+  | CreateEvalGuardrailConfigNumber$Outbound;
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("number"),
-    value: z.number(),
-    operator:
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
+export const CreateEvalLLMGuardrailConfig$outboundSchema: z.ZodType<
+  CreateEvalLLMGuardrailConfig$Outbound,
+  z.ZodTypeDef,
+  CreateEvalLLMGuardrailConfig
+> = z.union([
+  z.lazy(() => CreateEvalGuardrailConfigBoolean$outboundSchema),
+  z.lazy(() => CreateEvalGuardrailConfigCategorical$outboundSchema),
+  z.lazy(() => CreateEvalGuardrailConfigNumber$outboundSchema),
+]);
 
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber' from JSON`,
+export function createEvalLLMGuardrailConfigToJSON(
+  createEvalLLMGuardrailConfig: CreateEvalLLMGuardrailConfig,
+): string {
+  return JSON.stringify(
+    CreateEvalLLMGuardrailConfig$outboundSchema.parse(
+      createEvalLLMGuardrailConfig,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("categorical"),
-    values: z.array(z.string()),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical' from JSON`,
-  );
-}
+export const CreateEvalLLMOutputType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateEvalLLMOutputType
+> = z.nativeEnum(CreateEvalLLMOutputType);
 
 /** @internal */
-export const CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean$inboundSchema:
-  z.ZodType<
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    enabled: z.boolean().default(true),
-    alert_on_failure: z.boolean().default(false),
-    type: z.literal("boolean"),
-    value: z.boolean(),
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
+export const CreateEvalLLMType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateEvalLLMType
+> = z.nativeEnum(CreateEvalLLMType);
 
-export function createEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean$inboundSchema
-        .parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean' from JSON`,
-  );
-}
+/** @internal */
+export type CreateEvalLLMCategoricalLabels$Outbound = {
+  value: string;
+  description?: string | undefined;
+};
 
 /** @internal */
-export const CreateEvalLLMEvalsGuardrailConfig$inboundSchema: z.ZodType<
-  CreateEvalLLMEvalsGuardrailConfig,
+export const CreateEvalLLMCategoricalLabels$outboundSchema: z.ZodType<
+  CreateEvalLLMCategoricalLabels$Outbound,
   z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() =>
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean$inboundSchema
-  ),
-  z.lazy(() =>
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical$inboundSchema
-  ),
-  z.lazy(() =>
-    CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber$inboundSchema
-  ),
-]);
+  CreateEvalLLMCategoricalLabels
+> = z.object({
+  value: z.string(),
+  description: z.string().optional(),
+});
 
-export function createEvalLLMEvalsGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLLMEvalsGuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLLMEvalsGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLLMEvalsGuardrailConfig' from JSON`,
+export function createEvalLLMCategoricalLabelsToJSON(
+  createEvalLLMCategoricalLabels: CreateEvalLLMCategoricalLabels,
+): string {
+  return JSON.stringify(
+    CreateEvalLLMCategoricalLabels$outboundSchema.parse(
+      createEvalLLMCategoricalLabels,
+    ),
   );
 }
 
 /** @internal */
-export const CreateEvalLLMEvalsType$inboundSchema: z.ZodNativeEnum<
-  typeof CreateEvalLLMEvalsType
-> = z.nativeEnum(CreateEvalLLMEvalsType);
+export type Llm1$Outbound = {
+  guardrail_config?:
+    | CreateEvalGuardrailConfigBoolean$Outbound
+    | CreateEvalGuardrailConfigCategorical$Outbound
+    | CreateEvalGuardrailConfigNumber$Outbound
+    | null
+    | undefined;
+  output_type?: string | undefined;
+  type: string;
+  repetitions?: number | null | undefined;
+  prompt: string;
+  categories?: Array<string> | null | undefined;
+  categorical_labels?:
+    | Array<CreateEvalLLMCategoricalLabels$Outbound>
+    | null
+    | undefined;
+  dataset_id?: string | undefined;
+  path: string;
+  description: string;
+  key: string;
+  mode: "single";
+  model: string;
+};
 
 /** @internal */
-export const CreateEvalLLMEvalsResponseCategoricalLabels$inboundSchema:
-  z.ZodType<
-    CreateEvalLLMEvalsResponseCategoricalLabels,
-    z.ZodTypeDef,
-    unknown
-  > = z.object({
-    value: z.string(),
-    description: z.string().optional(),
+export const Llm1$outboundSchema: z.ZodType<Llm1$Outbound, z.ZodTypeDef, Llm1> =
+  z.object({
+    guardrailConfig: z.nullable(
+      z.union([
+        z.lazy(() => CreateEvalGuardrailConfigBoolean$outboundSchema),
+        z.lazy(() => CreateEvalGuardrailConfigCategorical$outboundSchema),
+        z.lazy(() => CreateEvalGuardrailConfigNumber$outboundSchema),
+      ]),
+    ).optional(),
+    outputType: CreateEvalLLMOutputType$outboundSchema.optional(),
+    type: CreateEvalLLMType$outboundSchema,
+    repetitions: z.nullable(z.number().int()).optional(),
+    prompt: z.string(),
+    categories: z.nullable(z.array(z.string())).optional(),
+    categoricalLabels: z.nullable(
+      z.array(z.lazy(() => CreateEvalLLMCategoricalLabels$outboundSchema)),
+    ).optional(),
+    datasetId: z.string().optional(),
+    path: z.string(),
+    description: z.string().default(""),
+    key: z.string(),
+    mode: z.literal("single"),
+    model: z.string(),
+  }).transform((v) => {
+    return remap$(v, {
+      guardrailConfig: "guardrail_config",
+      outputType: "output_type",
+      categoricalLabels: "categorical_labels",
+      datasetId: "dataset_id",
+    });
   });
 
-export function createEvalLLMEvalsResponseCategoricalLabelsFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  CreateEvalLLMEvalsResponseCategoricalLabels,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      CreateEvalLLMEvalsResponseCategoricalLabels$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'CreateEvalLLMEvalsResponseCategoricalLabels' from JSON`,
-  );
+export function llm1ToJSON(llm1: Llm1): string {
+  return JSON.stringify(Llm1$outboundSchema.parse(llm1));
 }
 
 /** @internal */
-export const CreateEvalLlm1$inboundSchema: z.ZodType<
-  CreateEvalLlm1,
-  z.ZodTypeDef,
-  unknown
-> = z.object({
-  _id: z.string(),
-  description: z.string(),
-  created: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated: z.string().default("2026-06-29T06:24:58.448Z"),
-  updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMBoolean$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMCategorical$inboundSchema
-      ),
-      z.lazy(() =>
-        CreateEvalGuardrailConfigEvalsResponse200ApplicationJSONResponseBody1LLMNumber$inboundSchema
-      ),
-    ]),
-  ).optional(),
-  type: CreateEvalLLMEvalsType$inboundSchema,
-  repetitions: z.nullable(z.number().int()).optional(),
-  prompt: z.string(),
-  categories: z.nullable(z.array(z.string())).optional(),
-  categorical_labels: z.nullable(
-    z.array(z.lazy(() =>
-      CreateEvalLLMEvalsResponseCategoricalLabels$inboundSchema
-    )),
-  ).optional(),
-  dataset_id: z.string().optional(),
-  key: z.string(),
-  mode: z.literal("single"),
-  model: z.string(),
-}).transform((v) => {
-  return remap$(v, {
-    "_id": "id",
-    "updated_by_id": "updatedById",
-    "guardrail_config": "guardrailConfig",
-    "categorical_labels": "categoricalLabels",
-    "dataset_id": "datasetId",
-  });
-});
+export type Llm$Outbound = Llm1$Outbound | Llm2$Outbound;
 
-export function createEvalLLM1FromJSON(
-  jsonString: string,
-): SafeParseResult<CreateEvalLlm1, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => CreateEvalLlm1$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'CreateEvalLlm1' from JSON`,
-  );
+/** @internal */
+export const Llm$outboundSchema: z.ZodType<Llm$Outbound, z.ZodTypeDef, Llm> = z
+  .union([
+    z.lazy(() => Llm1$outboundSchema),
+    z.lazy(() => Llm2$outboundSchema),
+  ]);
+
+export function llmToJSON(llm: Llm): string {
+  return JSON.stringify(Llm$outboundSchema.parse(llm));
 }
 
 /** @internal */
-export const ResponseBodyLLM$inboundSchema: z.ZodType<
-  ResponseBodyLLM,
+export type CreateEvalRequestBody$Outbound =
+  | Python$Outbound
+  | Llm1$Outbound
+  | Llm2$Outbound;
+
+/** @internal */
+export const CreateEvalRequestBody$outboundSchema: z.ZodType<
+  CreateEvalRequestBody$Outbound,
   z.ZodTypeDef,
-  unknown
+  CreateEvalRequestBody
 > = z.union([
-  z.lazy(() => CreateEvalLlm1$inboundSchema),
-  z.lazy(() => CreateEvalLlm2$inboundSchema),
+  z.lazy(() => Python$outboundSchema),
+  z.union([
+    z.lazy(() => Llm1$outboundSchema),
+    z.lazy(() => Llm2$outboundSchema),
+  ]),
 ]);
 
-export function responseBodyLLMFromJSON(
-  jsonString: string,
-): SafeParseResult<ResponseBodyLLM, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => ResponseBodyLLM$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'ResponseBodyLLM' from JSON`,
+export function createEvalRequestBodyToJSON(
+  createEvalRequestBody: CreateEvalRequestBody,
+): string {
+  return JSON.stringify(
+    CreateEvalRequestBody$outboundSchema.parse(createEvalRequestBody),
   );
 }
 
@@ -4438,16 +1205,13 @@ export const CreateEvalResponseBody$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.union([
-  z.lazy(() => CreateEvalResponseBodyHTTP$inboundSchema),
-  z.lazy(() => Ragas$inboundSchema),
-  z.lazy(() => Json$inboundSchema),
-  z.lazy(() => ResponseBodyPython$inboundSchema),
-  z.lazy(() => CreateEvalResponseBodyFunction$inboundSchema),
-  z.lazy(() => Typescript$inboundSchema),
-  z.union([
-    z.lazy(() => CreateEvalLlm1$inboundSchema),
-    z.lazy(() => CreateEvalLlm2$inboundSchema),
-  ]),
+  components.EvaluatorResponseLlm$inboundSchema,
+  components.EvaluatorResponseJsonSchema$inboundSchema,
+  components.EvaluatorResponseHttp$inboundSchema,
+  components.EvaluatorResponsePython$inboundSchema,
+  components.EvaluatorResponseFunction$inboundSchema,
+  components.EvaluatorResponseRagas$inboundSchema,
+  components.EvaluatorResponseTypescript$inboundSchema,
 ]);
 
 export function createEvalResponseBodyFromJSON(