@orq-ai/node 4.11.0-rc.9 → 4.11.0

package/packages/orq-rc/src/models/operations/updateeval.ts

@@ -0,0 +1,446 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import { safeParse } from "../../lib/schemas.js";
+import { 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 type CategoricalLabels = {
+  value: string;
+  description?: string | undefined;
+};
+
+export const Mode = {
+  Single: "single",
+  Jury: "jury",
+} as const;
+export type Mode = ClosedEnum<typeof Mode>;
+
+export type Retry = {
+  count?: number | undefined;
+  onCodes?: Array<number> | undefined;
+};
+
+export type Fallbacks = {
+  model: string;
+};
+
+export type Judges = {
+  model: string;
+  retry?: Retry | undefined;
+  fallbacks?: Array<Fallbacks> | undefined;
+};
+
+export type UpdateEvalRetry = {
+  count?: number | undefined;
+  onCodes?: Array<number> | undefined;
+};
+
+export type UpdateEvalFallbacks = {
+  model: string;
+};
+
+export type ReplacementJudges = {
+  model: string;
+  retry?: UpdateEvalRetry | undefined;
+  fallbacks?: Array<UpdateEvalFallbacks> | undefined;
+};
+
+export const TieValue = {
+  Tie: "Tie",
+} as const;
+export type TieValue = ClosedEnum<typeof TieValue>;
+
+export type Jury = {
+  judges: Array<Judges>;
+  replacementJudges?: Array<ReplacementJudges> | undefined;
+  minSuccessfulJudges?: number | undefined;
+  tieValue?: TieValue | undefined;
+};
+
+export const VersionIncrement = {
+  Major: "major",
+  Minor: "minor",
+  Patch: "patch",
+} as const;
+export type VersionIncrement = ClosedEnum<typeof VersionIncrement>;
+
+export type UpdateEvalRequestBody = {
+  /**
+   * Evaluator type. Optional on update — inferred from existing evaluator.
+   */
+  type?: string | undefined;
+  /**
+   * Project path. Optional on update — uses existing project if omitted.
+   */
+  path?: string | undefined;
+  key?: string | undefined;
+  description?: string | undefined;
+  prompt?: string | undefined;
+  outputType?: string | undefined;
+  categories?: Array<string> | null | undefined;
+  categoricalLabels?: Array<CategoricalLabels> | null | undefined;
+  repetitions?: number | undefined;
+  mode?: Mode | undefined;
+  model?: string | undefined;
+  jury?: Jury | undefined;
+  schema?: string | undefined;
+  url?: string | undefined;
+  method?: string | undefined;
+  headers?: { [k: string]: string } | undefined;
+  payload?: { [k: string]: any } | undefined;
+  code?: string | undefined;
+  guardrailConfig?: any | undefined;
+  versionIncrement?: VersionIncrement | undefined;
+  versionDescription?: string | undefined;
+};
+
+export type UpdateEvalRequest = {
+  id: string;
+  requestBody?: UpdateEvalRequestBody | undefined;
+};
+
+/**
+ * Successfully updated an eval
+ */
+export type UpdateEvalResponseBody =
+  | components.EvaluatorResponseLlm
+  | components.EvaluatorResponseJsonSchema
+  | components.EvaluatorResponseHttp
+  | components.EvaluatorResponsePython
+  | components.EvaluatorResponseFunction
+  | components.EvaluatorResponseRagas
+  | components.EvaluatorResponseTypescript;
+
+/** @internal */
+export type CategoricalLabels$Outbound = {
+  value: string;
+  description?: string | undefined;
+};
+
+/** @internal */
+export const CategoricalLabels$outboundSchema: z.ZodType<
+  CategoricalLabels$Outbound,
+  z.ZodTypeDef,
+  CategoricalLabels
+> = z.object({
+  value: z.string(),
+  description: z.string().optional(),
+});
+
+export function categoricalLabelsToJSON(
+  categoricalLabels: CategoricalLabels,
+): string {
+  return JSON.stringify(
+    CategoricalLabels$outboundSchema.parse(categoricalLabels),
+  );
+}
+
+/** @internal */
+export const Mode$outboundSchema: z.ZodNativeEnum<typeof Mode> = z.nativeEnum(
+  Mode,
+);
+
+/** @internal */
+export type Retry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
+
+/** @internal */
+export const Retry$outboundSchema: z.ZodType<
+  Retry$Outbound,
+  z.ZodTypeDef,
+  Retry
+> = 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 retryToJSON(retry: Retry): string {
+  return JSON.stringify(Retry$outboundSchema.parse(retry));
+}
+
+/** @internal */
+export type Fallbacks$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const Fallbacks$outboundSchema: z.ZodType<
+  Fallbacks$Outbound,
+  z.ZodTypeDef,
+  Fallbacks
+> = z.object({
+  model: z.string(),
+});
+
+export function fallbacksToJSON(fallbacks: Fallbacks): string {
+  return JSON.stringify(Fallbacks$outboundSchema.parse(fallbacks));
+}
+
+/** @internal */
+export type Judges$Outbound = {
+  model: string;
+  retry?: Retry$Outbound | undefined;
+  fallbacks?: Array<Fallbacks$Outbound> | undefined;
+};
+
+/** @internal */
+export const Judges$outboundSchema: z.ZodType<
+  Judges$Outbound,
+  z.ZodTypeDef,
+  Judges
+> = z.object({
+  model: z.string(),
+  retry: z.lazy(() => Retry$outboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => Fallbacks$outboundSchema)).optional(),
+});
+
+export function judgesToJSON(judges: Judges): string {
+  return JSON.stringify(Judges$outboundSchema.parse(judges));
+}
+
+/** @internal */
+export type UpdateEvalRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
+
+/** @internal */
+export const UpdateEvalRetry$outboundSchema: z.ZodType<
+  UpdateEvalRetry$Outbound,
+  z.ZodTypeDef,
+  UpdateEvalRetry
+> = 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 updateEvalRetryToJSON(
+  updateEvalRetry: UpdateEvalRetry,
+): string {
+  return JSON.stringify(UpdateEvalRetry$outboundSchema.parse(updateEvalRetry));
+}
+
+/** @internal */
+export type UpdateEvalFallbacks$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const UpdateEvalFallbacks$outboundSchema: z.ZodType<
+  UpdateEvalFallbacks$Outbound,
+  z.ZodTypeDef,
+  UpdateEvalFallbacks
+> = z.object({
+  model: z.string(),
+});
+
+export function updateEvalFallbacksToJSON(
+  updateEvalFallbacks: UpdateEvalFallbacks,
+): string {
+  return JSON.stringify(
+    UpdateEvalFallbacks$outboundSchema.parse(updateEvalFallbacks),
+  );
+}
+
+/** @internal */
+export type ReplacementJudges$Outbound = {
+  model: string;
+  retry?: UpdateEvalRetry$Outbound | undefined;
+  fallbacks?: Array<UpdateEvalFallbacks$Outbound> | undefined;
+};
+
+/** @internal */
+export const ReplacementJudges$outboundSchema: z.ZodType<
+  ReplacementJudges$Outbound,
+  z.ZodTypeDef,
+  ReplacementJudges
+> = z.object({
+  model: z.string(),
+  retry: z.lazy(() => UpdateEvalRetry$outboundSchema).optional(),
+  fallbacks: z.array(z.lazy(() => UpdateEvalFallbacks$outboundSchema))
+    .optional(),
+});
+
+export function replacementJudgesToJSON(
+  replacementJudges: ReplacementJudges,
+): string {
+  return JSON.stringify(
+    ReplacementJudges$outboundSchema.parse(replacementJudges),
+  );
+}
+
+/** @internal */
+export const TieValue$outboundSchema: z.ZodNativeEnum<typeof TieValue> = z
+  .nativeEnum(TieValue);
+
+/** @internal */
+export type Jury$Outbound = {
+  judges: Array<Judges$Outbound>;
+  replacement_judges?: Array<ReplacementJudges$Outbound> | undefined;
+  min_successful_judges: number;
+  tie_value: string;
+};
+
+/** @internal */
+export const Jury$outboundSchema: z.ZodType<Jury$Outbound, z.ZodTypeDef, Jury> =
+  z.object({
+    judges: z.array(z.lazy(() => Judges$outboundSchema)),
+    replacementJudges: z.array(z.lazy(() => ReplacementJudges$outboundSchema))
+      .optional(),
+    minSuccessfulJudges: z.number().int().default(2),
+    tieValue: TieValue$outboundSchema.default("Tie"),
+  }).transform((v) => {
+    return remap$(v, {
+      replacementJudges: "replacement_judges",
+      minSuccessfulJudges: "min_successful_judges",
+      tieValue: "tie_value",
+    });
+  });
+
+export function juryToJSON(jury: Jury): string {
+  return JSON.stringify(Jury$outboundSchema.parse(jury));
+}
+
+/** @internal */
+export const VersionIncrement$outboundSchema: z.ZodNativeEnum<
+  typeof VersionIncrement
+> = z.nativeEnum(VersionIncrement);
+
+/** @internal */
+export type UpdateEvalRequestBody$Outbound = {
+  type?: string | undefined;
+  path?: string | undefined;
+  key?: string | undefined;
+  description?: string | undefined;
+  prompt?: string | undefined;
+  output_type?: string | undefined;
+  categories?: Array<string> | null | undefined;
+  categorical_labels?: Array<CategoricalLabels$Outbound> | null | undefined;
+  repetitions?: number | undefined;
+  mode?: string | undefined;
+  model?: string | undefined;
+  jury?: Jury$Outbound | undefined;
+  schema?: string | undefined;
+  url?: string | undefined;
+  method?: string | undefined;
+  headers?: { [k: string]: string } | undefined;
+  payload?: { [k: string]: any } | undefined;
+  code?: string | undefined;
+  guardrail_config?: any | undefined;
+  versionIncrement?: string | undefined;
+  versionDescription?: string | undefined;
+};
+
+/** @internal */
+export const UpdateEvalRequestBody$outboundSchema: z.ZodType<
+  UpdateEvalRequestBody$Outbound,
+  z.ZodTypeDef,
+  UpdateEvalRequestBody
+> = z.object({
+  type: z.string().optional(),
+  path: z.string().optional(),
+  key: z.string().optional(),
+  description: z.string().optional(),
+  prompt: z.string().optional(),
+  outputType: z.string().optional(),
+  categories: z.nullable(z.array(z.string())).optional(),
+  categoricalLabels: z.nullable(
+    z.array(z.lazy(() => CategoricalLabels$outboundSchema)),
+  ).optional(),
+  repetitions: z.number().optional(),
+  mode: Mode$outboundSchema.optional(),
+  model: z.string().optional(),
+  jury: z.lazy(() => Jury$outboundSchema).optional(),
+  schema: z.string().optional(),
+  url: z.string().optional(),
+  method: z.string().optional(),
+  headers: z.record(z.string()).optional(),
+  payload: z.record(z.any()).optional(),
+  code: z.string().optional(),
+  guardrailConfig: z.any().optional(),
+  versionIncrement: VersionIncrement$outboundSchema.optional(),
+  versionDescription: z.string().optional(),
+}).transform((v) => {
+  return remap$(v, {
+    outputType: "output_type",
+    categoricalLabels: "categorical_labels",
+    guardrailConfig: "guardrail_config",
+  });
+});
+
+export function updateEvalRequestBodyToJSON(
+  updateEvalRequestBody: UpdateEvalRequestBody,
+): string {
+  return JSON.stringify(
+    UpdateEvalRequestBody$outboundSchema.parse(updateEvalRequestBody),
+  );
+}
+
+/** @internal */
+export type UpdateEvalRequest$Outbound = {
+  id: string;
+  RequestBody?: UpdateEvalRequestBody$Outbound | undefined;
+};
+
+/** @internal */
+export const UpdateEvalRequest$outboundSchema: z.ZodType<
+  UpdateEvalRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateEvalRequest
+> = z.object({
+  id: z.string(),
+  requestBody: z.lazy(() => UpdateEvalRequestBody$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    requestBody: "RequestBody",
+  });
+});
+
+export function updateEvalRequestToJSON(
+  updateEvalRequest: UpdateEvalRequest,
+): string {
+  return JSON.stringify(
+    UpdateEvalRequest$outboundSchema.parse(updateEvalRequest),
+  );
+}
+
+/** @internal */
+export const UpdateEvalResponseBody$inboundSchema: z.ZodType<
+  UpdateEvalResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.union([
+  components.EvaluatorResponseLlm$inboundSchema,
+  components.EvaluatorResponseJsonSchema$inboundSchema,
+  components.EvaluatorResponseHttp$inboundSchema,
+  components.EvaluatorResponsePython$inboundSchema,
+  components.EvaluatorResponseFunction$inboundSchema,
+  components.EvaluatorResponseRagas$inboundSchema,
+  components.EvaluatorResponseTypescript$inboundSchema,
+]);
+
+export function updateEvalResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<UpdateEvalResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => UpdateEvalResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'UpdateEvalResponseBody' from JSON`,
+  );
+}

package/packages/orq-rc/src/models/operations/updateidentity.ts

@@ -0,0 +1,43 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+import { remap as remap$ } from "../../lib/primitives.js";
+import * as components from "../components/index.js";
+
+export type UpdateIdentityRequest = {
+  /**
+   * Identity ID to update.
+   */
+  id: string;
+  updateIdentityRequest: components.UpdateIdentityRequest;
+};
+
+/** @internal */
+export type UpdateIdentityRequest$Outbound = {
+  id: string;
+  UpdateIdentityRequest: components.UpdateIdentityRequest$Outbound;
+};
+
+/** @internal */
+export const UpdateIdentityRequest$outboundSchema: z.ZodType<
+  UpdateIdentityRequest$Outbound,
+  z.ZodTypeDef,
+  UpdateIdentityRequest
+> = z.object({
+  id: z.string(),
+  updateIdentityRequest: components.UpdateIdentityRequest$outboundSchema,
+}).transform((v) => {
+  return remap$(v, {
+    updateIdentityRequest: "UpdateIdentityRequest",
+  });
+});
+
+export function updateIdentityRequestToJSON(
+  updateIdentityRequest: UpdateIdentityRequest,
+): string {
+  return JSON.stringify(
+    UpdateIdentityRequest$outboundSchema.parse(updateIdentityRequest),
+  );
+}