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

package/src/models/components/evaluatorresponsefunction.ts

@@ -5,49 +5,9 @@
 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 EvaluatorResponseFunctionGuardrailConfigOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type EvaluatorResponseFunctionGuardrailConfigOperator = ClosedEnum<
-  typeof EvaluatorResponseFunctionGuardrailConfigOperator
->;
-
-export type EvaluatorResponseFunctionGuardrailConfigNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: EvaluatorResponseFunctionGuardrailConfigOperator;
-};
-
-export type EvaluatorResponseFunctionGuardrailConfigCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type EvaluatorResponseFunctionGuardrailConfigBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type EvaluatorResponseFunctionGuardrailConfig =
-  | EvaluatorResponseFunctionGuardrailConfigBoolean
-  | EvaluatorResponseFunctionGuardrailConfigCategorical
-  | EvaluatorResponseFunctionGuardrailConfigNumber;
-
 export type ThirtyTwo = {
   type: "grammar_diversity";
 };
@@ -228,12 +188,7 @@ export type EvaluatorResponseFunction = {
   created: string;
   updated: string;
   updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | EvaluatorResponseFunctionGuardrailConfigBoolean
-    | EvaluatorResponseFunctionGuardrailConfigCategorical
-    | EvaluatorResponseFunctionGuardrailConfigNumber
-    | null
-    | undefined;
+  guardrailConfig?: any | undefined;
   type: "function_eval";
   functionParams:
     | One
@@ -271,140 +226,6 @@ export type EvaluatorResponseFunction = {
   key: string;
 };
 
-/** @internal */
-export const EvaluatorResponseFunctionGuardrailConfigOperator$inboundSchema:
-  z.ZodNativeEnum<typeof EvaluatorResponseFunctionGuardrailConfigOperator> = z
-    .nativeEnum(EvaluatorResponseFunctionGuardrailConfigOperator);
-
-/** @internal */
-export const EvaluatorResponseFunctionGuardrailConfigNumber$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseFunctionGuardrailConfigNumber,
-    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: EvaluatorResponseFunctionGuardrailConfigOperator$inboundSchema,
-  }).transform((v) => {
-    return remap$(v, {
-      "alert_on_failure": "alertOnFailure",
-    });
-  });
-
-export function evaluatorResponseFunctionGuardrailConfigNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseFunctionGuardrailConfigNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseFunctionGuardrailConfigNumber$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseFunctionGuardrailConfigNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseFunctionGuardrailConfigCategorical$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseFunctionGuardrailConfigCategorical,
-    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 evaluatorResponseFunctionGuardrailConfigCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseFunctionGuardrailConfigCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseFunctionGuardrailConfigCategorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseFunctionGuardrailConfigCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseFunctionGuardrailConfigBoolean$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseFunctionGuardrailConfigBoolean,
-    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 evaluatorResponseFunctionGuardrailConfigBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseFunctionGuardrailConfigBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseFunctionGuardrailConfigBoolean$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseFunctionGuardrailConfigBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseFunctionGuardrailConfig$inboundSchema: z.ZodType<
-  EvaluatorResponseFunctionGuardrailConfig,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => EvaluatorResponseFunctionGuardrailConfigBoolean$inboundSchema),
-  z.lazy(() =>
-    EvaluatorResponseFunctionGuardrailConfigCategorical$inboundSchema
-  ),
-  z.lazy(() => EvaluatorResponseFunctionGuardrailConfigNumber$inboundSchema),
-]);
-
-export function evaluatorResponseFunctionGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseFunctionGuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseFunctionGuardrailConfig$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseFunctionGuardrailConfig' from JSON`,
-  );
-}
-
 /** @internal */
 export const ThirtyTwo$inboundSchema: z.ZodType<
   ThirtyTwo,
@@ -1035,22 +856,10 @@ export const EvaluatorResponseFunction$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(() =>
-        EvaluatorResponseFunctionGuardrailConfigBoolean$inboundSchema
-      ),
-      z.lazy(() =>
-        EvaluatorResponseFunctionGuardrailConfigCategorical$inboundSchema
-      ),
-      z.lazy(() =>
-        EvaluatorResponseFunctionGuardrailConfigNumber$inboundSchema
-      ),
-    ]),
-  ).optional(),
+  guardrail_config: z.any().optional(),
   type: z.literal("function_eval"),
   function_params: z.union([
     z.lazy(() => One$inboundSchema),

package/src/models/components/evaluatorresponsehttp.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 EvaluatorResponseHttpGuardrailConfigOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type EvaluatorResponseHttpGuardrailConfigOperator = ClosedEnum<
-  typeof EvaluatorResponseHttpGuardrailConfigOperator
->;
-
-export type EvaluatorResponseHttpGuardrailConfigNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: EvaluatorResponseHttpGuardrailConfigOperator;
-};
-
-export type EvaluatorResponseHttpGuardrailConfigCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type EvaluatorResponseHttpGuardrailConfigBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type EvaluatorResponseHttpGuardrailConfig =
-  | EvaluatorResponseHttpGuardrailConfigBoolean
-  | EvaluatorResponseHttpGuardrailConfigCategorical
-  | EvaluatorResponseHttpGuardrailConfigNumber;
-
 export const Method = {
   Get: "GET",
   Post: "POST",
@@ -60,12 +21,7 @@ export type EvaluatorResponseHttp = {
   created: string;
   updated: string;
   updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | EvaluatorResponseHttpGuardrailConfigBoolean
-    | EvaluatorResponseHttpGuardrailConfigCategorical
-    | EvaluatorResponseHttpGuardrailConfigNumber
-    | null
-    | undefined;
+  guardrailConfig?: any | undefined;
   type: "http_eval";
   url: string;
   method: Method;
@@ -74,130 +30,6 @@ export type EvaluatorResponseHttp = {
   key: string;
 };
 
-/** @internal */
-export const EvaluatorResponseHttpGuardrailConfigOperator$inboundSchema:
-  z.ZodNativeEnum<typeof EvaluatorResponseHttpGuardrailConfigOperator> = z
-    .nativeEnum(EvaluatorResponseHttpGuardrailConfigOperator);
-
-/** @internal */
-export const EvaluatorResponseHttpGuardrailConfigNumber$inboundSchema:
-  z.ZodType<EvaluatorResponseHttpGuardrailConfigNumber, 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: EvaluatorResponseHttpGuardrailConfigOperator$inboundSchema,
-    }).transform((v) => {
-      return remap$(v, {
-        "alert_on_failure": "alertOnFailure",
-      });
-    });
-
-export function evaluatorResponseHttpGuardrailConfigNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseHttpGuardrailConfigNumber,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseHttpGuardrailConfigNumber$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseHttpGuardrailConfigNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseHttpGuardrailConfigCategorical$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseHttpGuardrailConfigCategorical,
-    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 evaluatorResponseHttpGuardrailConfigCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseHttpGuardrailConfigCategorical,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseHttpGuardrailConfigCategorical$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseHttpGuardrailConfigCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseHttpGuardrailConfigBoolean$inboundSchema:
-  z.ZodType<
-    EvaluatorResponseHttpGuardrailConfigBoolean,
-    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 evaluatorResponseHttpGuardrailConfigBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseHttpGuardrailConfigBoolean,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseHttpGuardrailConfigBoolean$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseHttpGuardrailConfigBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseHttpGuardrailConfig$inboundSchema: z.ZodType<
-  EvaluatorResponseHttpGuardrailConfig,
-  z.ZodTypeDef,
-  unknown
-> = z.union([
-  z.lazy(() => EvaluatorResponseHttpGuardrailConfigBoolean$inboundSchema),
-  z.lazy(() => EvaluatorResponseHttpGuardrailConfigCategorical$inboundSchema),
-  z.lazy(() => EvaluatorResponseHttpGuardrailConfigNumber$inboundSchema),
-]);
-
-export function evaluatorResponseHttpGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<EvaluatorResponseHttpGuardrailConfig, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseHttpGuardrailConfig$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'EvaluatorResponseHttpGuardrailConfig' from JSON`,
-  );
-}
-
 /** @internal */
 export const Method$inboundSchema: z.ZodNativeEnum<typeof Method> = z
   .nativeEnum(Method);
@@ -210,18 +42,10 @@ export const EvaluatorResponseHttp$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(() => EvaluatorResponseHttpGuardrailConfigBoolean$inboundSchema),
-      z.lazy(() =>
-        EvaluatorResponseHttpGuardrailConfigCategorical$inboundSchema
-      ),
-      z.lazy(() => EvaluatorResponseHttpGuardrailConfigNumber$inboundSchema),
-    ]),
-  ).optional(),
+  guardrail_config: z.any().optional(),
   type: z.literal("http_eval"),
   url: z.string(),
   method: Method$inboundSchema,

package/src/models/components/evaluatorresponsejsonschema.ts

@@ -5,175 +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 GuardrailConfigOperator = {
-  Eq: "eq",
-  Ne: "ne",
-  Gt: "gt",
-  Gte: "gte",
-  Lt: "lt",
-  Lte: "lte",
-} as const;
-export type GuardrailConfigOperator = ClosedEnum<
-  typeof GuardrailConfigOperator
->;
-
-export type GuardrailConfigNumber = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "number";
-  value: number;
-  operator: GuardrailConfigOperator;
-};
-
-export type GuardrailConfigCategorical = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "categorical";
-  values: Array<string>;
-};
-
-export type GuardrailConfigBoolean = {
-  enabled: boolean;
-  alertOnFailure: boolean;
-  type: "boolean";
-  value: boolean;
-};
-
-export type EvaluatorResponseJsonSchemaGuardrailConfig =
-  | GuardrailConfigBoolean
-  | GuardrailConfigCategorical
-  | GuardrailConfigNumber;
-
 export type EvaluatorResponseJsonSchema = {
   id: string;
   description: string;
   created: string;
   updated: string;
   updatedById?: string | null | undefined;
-  guardrailConfig?:
-    | GuardrailConfigBoolean
-    | GuardrailConfigCategorical
-    | GuardrailConfigNumber
-    | null
-    | undefined;
+  guardrailConfig?: any | undefined;
   type: "json_schema";
   schema: string;
   key: string;
 };
 
-/** @internal */
-export const GuardrailConfigOperator$inboundSchema: z.ZodNativeEnum<
-  typeof GuardrailConfigOperator
-> = z.nativeEnum(GuardrailConfigOperator);
-
-/** @internal */
-export const GuardrailConfigNumber$inboundSchema: z.ZodType<
-  GuardrailConfigNumber,
-  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: GuardrailConfigOperator$inboundSchema,
-}).transform((v) => {
-  return remap$(v, {
-    "alert_on_failure": "alertOnFailure",
-  });
-});
-
-export function guardrailConfigNumberFromJSON(
-  jsonString: string,
-): SafeParseResult<GuardrailConfigNumber, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GuardrailConfigNumber$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GuardrailConfigNumber' from JSON`,
-  );
-}
-
-/** @internal */
-export const GuardrailConfigCategorical$inboundSchema: z.ZodType<
-  GuardrailConfigCategorical,
-  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 guardrailConfigCategoricalFromJSON(
-  jsonString: string,
-): SafeParseResult<GuardrailConfigCategorical, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GuardrailConfigCategorical$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GuardrailConfigCategorical' from JSON`,
-  );
-}
-
-/** @internal */
-export const GuardrailConfigBoolean$inboundSchema: z.ZodType<
-  GuardrailConfigBoolean,
-  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 guardrailConfigBooleanFromJSON(
-  jsonString: string,
-): SafeParseResult<GuardrailConfigBoolean, SDKValidationError> {
-  return safeParse(
-    jsonString,
-    (x) => GuardrailConfigBoolean$inboundSchema.parse(JSON.parse(x)),
-    `Failed to parse 'GuardrailConfigBoolean' from JSON`,
-  );
-}
-
-/** @internal */
-export const EvaluatorResponseJsonSchemaGuardrailConfig$inboundSchema:
-  z.ZodType<EvaluatorResponseJsonSchemaGuardrailConfig, z.ZodTypeDef, unknown> =
-    z.union([
-      z.lazy(() => GuardrailConfigBoolean$inboundSchema),
-      z.lazy(() => GuardrailConfigCategorical$inboundSchema),
-      z.lazy(() => GuardrailConfigNumber$inboundSchema),
-    ]);
-
-export function evaluatorResponseJsonSchemaGuardrailConfigFromJSON(
-  jsonString: string,
-): SafeParseResult<
-  EvaluatorResponseJsonSchemaGuardrailConfig,
-  SDKValidationError
-> {
-  return safeParse(
-    jsonString,
-    (x) =>
-      EvaluatorResponseJsonSchemaGuardrailConfig$inboundSchema.parse(
-        JSON.parse(x),
-      ),
-    `Failed to parse 'EvaluatorResponseJsonSchemaGuardrailConfig' from JSON`,
-  );
-}
-
 /** @internal */
 export const EvaluatorResponseJsonSchema$inboundSchema: z.ZodType<
   EvaluatorResponseJsonSchema,
@@ -182,16 +28,10 @@ export const EvaluatorResponseJsonSchema$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(() => GuardrailConfigBoolean$inboundSchema),
-      z.lazy(() => GuardrailConfigCategorical$inboundSchema),
-      z.lazy(() => GuardrailConfigNumber$inboundSchema),
-    ]),
-  ).optional(),
+  guardrail_config: z.any().optional(),
   type: z.literal("json_schema"),
   schema: z.string(),
   key: z.string(),