@orq-ai/node 4.11.0-rc.66 → 4.11.0-rc.68

package/src/models/components/evaluatorresponsellm.ts

@@ -9,40 +9,6 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const Operator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type Operator = ClosedEnum<typeof Operator>;
-
-export type NumberT = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: Operator;
-};
-
-export type Categorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type Boolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type GuardrailConfig = Boolean | Categorical | NumberT;
-
 export type CategoricalLabels = {
   value: string;
   description?: string | undefined;
@@ -102,7 +68,7 @@ export type EvaluatorResponseLlm = {
   created: string;
   updated: string;
   updatedById?: string | null | undefined;
-  guardrailConfig?: Boolean | Categorical | NumberT | null | undefined;
+  guardrailConfig?: any | undefined;
   type: "llm_eval";
   repetitions?: number | null | undefined;
   prompt: string;
@@ -115,104 +81,6 @@ export type EvaluatorResponseLlm = {
   jury?: Jury | undefined;
 };
 
-/** @internal */
-export const Operator$inboundSchema: z.ZodNativeEnum<typeof Operator> = z
-  .nativeEnum(Operator);
-
-/** @internal */
-export const NumberT$inboundSchema: z.ZodType<NumberT, 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: Operator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function numberFromJSON(
-  jsonString: string,
-): SafeParseResult<NumberT, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => NumberT$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'NumberT' from JSON`,
-  );
-}
-
-/** @internal */
-export const Categorical$inboundSchema: z.ZodType<
-  Categorical,
-  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 categoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<Categorical, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Categorical$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Categorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const Boolean$inboundSchema: z.ZodType<Boolean, 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 booleanFromJSON(
-  jsonString: string,
-): SafeParseResult<Boolean, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => Boolean$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'Boolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const GuardrailConfig$inboundSchema: z.ZodType<
-  GuardrailConfig,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => Boolean$inboundSchema),
-  z.lazy(() => Categorical$inboundSchema),
-  z.lazy(() => NumberT$inboundSchema),
-]);
-
-export function guardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<GuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GuardrailConfig' from JSON`,
-  );
-}
-
 /** @internal */
 export const CategoricalLabels$inboundSchema: z.ZodType<
   CategoricalLabels,
@@ -399,16 +267,10 @@ export const EvaluatorResponseLlm$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2026-07-01T12:26:04.887Z"),
-  updated: z.string().default("2026-07-01T12:26:04.887Z"),
+  created: z.string().default("2026-07-02T01:19:40.024Z"),
+  updated: z.string().default("2026-07-02T01:19:40.024Z"),
   updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() => Boolean$inboundSchema),
-      z.lazy(() => Categorical$inboundSchema),
-      z.lazy(() => NumberT$inboundSchema),
-    ]),
-  ).optional(),
+  guardrail_config: z.any().optional(),
   type: z.literal("llm_eval"),
   repetitions: z.nullable(z.number().int()).optional(),
   prompt: z.string(),

package/src/models/components/evaluatorresponsepython.ts

@@ -5,193 +5,21 @@
 import * as z from "zod/v3";
 import { remap as remap$ } from "../../lib/primitives.js";
 import { safeParse } from "../../lib/schemas.js";
-import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const EvaluatorResponsePythonGuardrailConfigOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type EvaluatorResponsePythonGuardrailConfigOperator = ClosedEnum<
-  typeof EvaluatorResponsePythonGuardrailConfigOperator
->;
-
-export type EvaluatorResponsePythonGuardrailConfigNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: EvaluatorResponsePythonGuardrailConfigOperator;
-};
-
-export type EvaluatorResponsePythonGuardrailConfigCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type EvaluatorResponsePythonGuardrailConfigBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type EvaluatorResponsePythonGuardrailConfig =
-  | EvaluatorResponsePythonGuardrailConfigBoolean
-  | EvaluatorResponsePythonGuardrailConfigCategorical
-  | EvaluatorResponsePythonGuardrailConfigNumber;
-
 export type EvaluatorResponsePython = {
   id: string;
   description: string;
   created: string;
   updated: string;
   updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | EvaluatorResponsePythonGuardrailConfigBoolean
-    | EvaluatorResponsePythonGuardrailConfigCategorical
-    | EvaluatorResponsePythonGuardrailConfigNumber
-    | null
-    | undefined;
+  guardrailConfig?: any | undefined;
   code: string;
   type: "python_eval";
   key: string;
 };
 
-/** @internal */
-export const EvaluatorResponsePythonGuardrailConfigOperator$inboundSchema:
-  z.ZodNativeEnum<typeof EvaluatorResponsePythonGuardrailConfigOperator> = z
-    .nativeEnum(EvaluatorResponsePythonGuardrailConfigOperator);
-
-/** @internal */
-export const EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema:
-  z.ZodType<
-    EvaluatorResponsePythonGuardrailConfigNumber,
-    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: EvaluatorResponsePythonGuardrailConfigOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function evaluatorResponsePythonGuardrailConfigNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponsePythonGuardrailConfigNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponsePythonGuardrailConfigNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema:
-  z.ZodType<
-    EvaluatorResponsePythonGuardrailConfigCategorical,
-    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 evaluatorResponsePythonGuardrailConfigCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponsePythonGuardrailConfigCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponsePythonGuardrailConfigCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema:
-  z.ZodType<
-    EvaluatorResponsePythonGuardrailConfigBoolean,
-    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 evaluatorResponsePythonGuardrailConfigBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponsePythonGuardrailConfigBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponsePythonGuardrailConfigBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponsePythonGuardrailConfig$inboundSchema: z.ZodType<
-  EvaluatorResponsePythonGuardrailConfig,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema),
-  z.lazy(() => EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema),
-  z.lazy(() => EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema),
-]);
-
-export function evaluatorResponsePythonGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<EvaluatorResponsePythonGuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponsePythonGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EvaluatorResponsePythonGuardrailConfig' from JSON`,
-  );
-}
-
 /** @internal */
 export const EvaluatorResponsePython$inboundSchema: z.ZodType<
   EvaluatorResponsePython,
@@ -200,18 +28,10 @@ export const EvaluatorResponsePython$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2026-07-01T12:26:04.887Z"),
-  updated: z.string().default("2026-07-01T12:26:04.887Z"),
+  created: z.string().default("2026-07-02T01:19:40.024Z"),
+  updated: z.string().default("2026-07-02T01:19:40.024Z"),
   updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() => EvaluatorResponsePythonGuardrailConfigBoolean$inboundSchema),
-      z.lazy(() =>
-        EvaluatorResponsePythonGuardrailConfigCategorical$inboundSchema
-      ),
-      z.lazy(() => EvaluatorResponsePythonGuardrailConfigNumber$inboundSchema),
-    ]),
-  ).optional(),
+  guardrail_config: z.any().optional(),
   code: z.string(),
   type: z.literal("python_eval"),
   key: z.string(),

package/src/models/components/evaluatorresponseragas.ts

@@ -9,45 +9,6 @@ import { ClosedEnum } from "../../types/enums.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
 
-export const EvaluatorResponseRagasGuardrailConfigOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type EvaluatorResponseRagasGuardrailConfigOperator = ClosedEnum<
-  typeof EvaluatorResponseRagasGuardrailConfigOperator
->;
-
-export type EvaluatorResponseRagasGuardrailConfigNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: EvaluatorResponseRagasGuardrailConfigOperator;
-};
-
-export type EvaluatorResponseRagasGuardrailConfigCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type EvaluatorResponseRagasGuardrailConfigBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type EvaluatorResponseRagasGuardrailConfig =
-  | EvaluatorResponseRagasGuardrailConfigBoolean
-  | EvaluatorResponseRagasGuardrailConfigCategorical
-  | EvaluatorResponseRagasGuardrailConfigNumber;
-
 export const RagasMetric = {
   ContextPrecision: "context_precision",
   ContextRecall: "context_recall",
@@ -70,145 +31,13 @@ export type EvaluatorResponseRagas = {
   created: string;
   updated: string;
   updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | EvaluatorResponseRagasGuardrailConfigBoolean
-    | EvaluatorResponseRagasGuardrailConfigCategorical
-    | EvaluatorResponseRagasGuardrailConfigNumber
-    | null
-    | undefined;
+  guardrailConfig?: any | undefined;
   type: "ragas";
   ragasMetric: RagasMetric;
   key: string;
   model: string;
 };
 
-/** @internal */
-export const EvaluatorResponseRagasGuardrailConfigOperator$inboundSchema:
-  z.ZodNativeEnum<typeof EvaluatorResponseRagasGuardrailConfigOperator> = z
-    .nativeEnum(EvaluatorResponseRagasGuardrailConfigOperator);
-
-/** @internal */
-export const EvaluatorResponseRagasGuardrailConfigNumber$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseRagasGuardrailConfigNumber,
-    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: EvaluatorResponseRagasGuardrailConfigOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function evaluatorResponseRagasGuardrailConfigNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseRagasGuardrailConfigNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseRagasGuardrailConfigNumber$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseRagasGuardrailConfigNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseRagasGuardrailConfigCategorical$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseRagasGuardrailConfigCategorical,
-    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 evaluatorResponseRagasGuardrailConfigCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseRagasGuardrailConfigCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseRagasGuardrailConfigCategorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseRagasGuardrailConfigCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseRagasGuardrailConfigBoolean$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseRagasGuardrailConfigBoolean,
-    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 evaluatorResponseRagasGuardrailConfigBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseRagasGuardrailConfigBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseRagasGuardrailConfigBoolean$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseRagasGuardrailConfigBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseRagasGuardrailConfig$inboundSchema: z.ZodType<
-  EvaluatorResponseRagasGuardrailConfig,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => EvaluatorResponseRagasGuardrailConfigBoolean$inboundSchema),
-  z.lazy(() => EvaluatorResponseRagasGuardrailConfigCategorical$inboundSchema),
-  z.lazy(() => EvaluatorResponseRagasGuardrailConfigNumber$inboundSchema),
-]);
-
-export function evaluatorResponseRagasGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<EvaluatorResponseRagasGuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseRagasGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EvaluatorResponseRagasGuardrailConfig' from JSON`,
-  );
-}
-
 /** @internal */
 export const RagasMetric$inboundSchema: z.ZodNativeEnum<typeof RagasMetric> = z
   .nativeEnum(RagasMetric);
@@ -221,18 +50,10 @@ export const EvaluatorResponseRagas$inboundSchema: z.ZodType<
 > = z.object({
   _id: z.string(),
   description: z.string(),
-  created: z.string().default("2026-07-01T12:26:04.887Z"),
-  updated: z.string().default("2026-07-01T12:26:04.887Z"),
+  created: z.string().default("2026-07-02T01:19:40.024Z"),
+  updated: z.string().default("2026-07-02T01:19:40.024Z"),
   updated_by_id: z.nullable(z.string()).optional(),
-  guardrail_config: z.nullable(
-    z.union([
-      z.lazy(() => EvaluatorResponseRagasGuardrailConfigBoolean$inboundSchema),
-      z.lazy(() =>
-        EvaluatorResponseRagasGuardrailConfigCategorical$inboundSchema
-      ),
-      z.lazy(() => EvaluatorResponseRagasGuardrailConfigNumber$inboundSchema),
-    ]),
-  ).optional(),
+  guardrail_config: z.any().optional(),
   type: z.literal("ragas"),
   ragas_metric: RagasMetric$inboundSchema,
   key: z.string(),