@orq-ai/node 4.8.0-rc.8 → 4.8.1

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

@@ -0,0 +1,890 @@
+/*
+ * 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 CreateRerankFallbacks = {
+  /**
+   * Fallback model identifier
+   */
+  model: string;
+};
+
+/**
+ * Retry configuration for the request
+ */
+export type CreateRerankRetry = {
+  /**
+   * Number of retry attempts (1-5)
+   */
+  count?: number | undefined;
+  /**
+   * HTTP status codes that trigger retry logic
+   */
+  onCodes?: Array<number> | undefined;
+};
+
+export const CreateRerankType = {
+  ExactMatch: "exact_match",
+} as const;
+export type CreateRerankType = ClosedEnum<typeof CreateRerankType>;
+
+/**
+ * Cache configuration for the request.
+ */
+export type CreateRerankCache = {
+  /**
+   * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
+   */
+  ttl?: number | undefined;
+  type: CreateRerankType;
+};
+
+export const CreateRerankLoadBalancerType = {
+  WeightBased: "weight_based",
+} as const;
+export type CreateRerankLoadBalancerType = ClosedEnum<
+  typeof CreateRerankLoadBalancerType
+>;
+
+export type CreateRerankLoadBalancerModels = {
+  /**
+   * Model identifier for load balancing
+   */
+  model: string;
+  /**
+   * Weight assigned to this model for load balancing
+   */
+  weight?: number | undefined;
+};
+
+export type CreateRerankLoadBalancer1 = {
+  type: CreateRerankLoadBalancerType;
+  models: Array<CreateRerankLoadBalancerModels>;
+};
+
+/**
+ * Load balancer configuration for the request.
+ */
+export type CreateRerankLoadBalancer = CreateRerankLoadBalancer1;
+
+/**
+ * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
+ */
+export type CreateRerankTimeout = {
+  /**
+   * Timeout value in milliseconds
+   */
+  callTimeout: number;
+};
+
+export type CreateRerankRouterRerankFallbacks = {
+  /**
+   * Fallback model identifier
+   */
+  model: string;
+};
+
+export const CreateRerankRouterRerankType = {
+  ExactMatch: "exact_match",
+} as const;
+export type CreateRerankRouterRerankType = ClosedEnum<
+  typeof CreateRerankRouterRerankType
+>;
+
+/**
+ * Cache configuration for the request.
+ */
+export type CreateRerankRouterRerankCache = {
+  /**
+   * Time to live for cached responses in seconds. Maximum 259200 seconds (3 days).
+   */
+  ttl?: number | undefined;
+  type: CreateRerankRouterRerankType;
+};
+
+/**
+ * Retry configuration for the request
+ */
+export type CreateRerankRouterRerankRetry = {
+  /**
+   * Number of retry attempts (1-5)
+   */
+  count?: number | undefined;
+  /**
+   * HTTP status codes that trigger retry logic
+   */
+  onCodes?: Array<number> | undefined;
+};
+
+export const CreateRerankLoadBalancerRouterRerankType = {
+  WeightBased: "weight_based",
+} as const;
+export type CreateRerankLoadBalancerRouterRerankType = ClosedEnum<
+  typeof CreateRerankLoadBalancerRouterRerankType
+>;
+
+export type CreateRerankLoadBalancerRouterRerankModels = {
+  /**
+   * Model identifier for load balancing
+   */
+  model: string;
+  /**
+   * Weight assigned to this model for load balancing
+   */
+  weight?: number | undefined;
+};
+
+export type CreateRerankLoadBalancerRouterRerank1 = {
+  type: CreateRerankLoadBalancerRouterRerankType;
+  models: Array<CreateRerankLoadBalancerRouterRerankModels>;
+};
+
+/**
+ * Array of models with weights for load balancing requests
+ */
+export type CreateRerankRouterRerankLoadBalancer =
+  CreateRerankLoadBalancerRouterRerank1;
+
+/**
+ * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
+ */
+export type CreateRerankRouterRerankTimeout = {
+  /**
+   * Timeout value in milliseconds
+   */
+  callTimeout: number;
+};
+
+export type CreateRerankOrq = {
+  /**
+   * The name to display on the trace. If not specified, the default system name will be used.
+   */
+  name?: string | undefined;
+  /**
+   * Array of fallback models to use if primary model fails
+   */
+  fallbacks?: Array<CreateRerankRouterRerankFallbacks> | undefined;
+  /**
+   * Cache configuration for the request.
+   */
+  cache?: CreateRerankRouterRerankCache | undefined;
+  /**
+   * Retry configuration for the request
+   */
+  retry?: CreateRerankRouterRerankRetry | undefined;
+  /**
+   * Information about the identity making the request. If the identity does not exist, it will be created automatically.
+   */
+  identity?: components.PublicIdentity | undefined;
+  /**
+   * @deprecated Use identity instead. Information about the contact making the request.
+   *
+   * @deprecated field: This will be removed in a future release, please migrate away from it as soon as possible.
+   */
+  contact?: components.PublicContact | undefined;
+  /**
+   * Array of models with weights for load balancing requests
+   */
+  loadBalancer?: CreateRerankLoadBalancerRouterRerank1 | undefined;
+  /**
+   * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
+   */
+  timeout?: CreateRerankRouterRerankTimeout | undefined;
+};
+
+/**
+ * input
+ */
+export type CreateRerankRequestBody = {
+  /**
+   * The search query
+   */
+  query: string;
+  /**
+   * A list of texts that will be compared to the `query`. For optimal performance we recommend against sending more than 1,000 documents in a single request.
+   */
+  documents: Array<string>;
+  /**
+   * The identifier of the model to use
+   */
+  model: string;
+  /**
+   * The number of most relevant documents or indices to return, defaults to the length of the documents
+   */
+  topN?: number | undefined;
+  /**
+   * The filename of the document to rerank
+   */
+  filename?: string | null | undefined;
+  /**
+   * The name to display on the trace. If not specified, the default system name will be used.
+   */
+  name?: string | undefined;
+  /**
+   * Array of fallback models to use if primary model fails
+   */
+  fallbacks?: Array<CreateRerankFallbacks> | undefined;
+  /**
+   * Retry configuration for the request
+   */
+  retry?: CreateRerankRetry | undefined;
+  /**
+   * Cache configuration for the request.
+   */
+  cache?: CreateRerankCache | undefined;
+  /**
+   * Load balancer configuration for the request.
+   */
+  loadBalancer?: CreateRerankLoadBalancer1 | undefined;
+  /**
+   * Timeout configuration to apply to the request. If the request exceeds the timeout, it will be retried or fallback to the next model if configured.
+   */
+  timeout?: CreateRerankTimeout | undefined;
+  orq?: CreateRerankOrq | undefined;
+};
+
+export const CreateRerankObject = {
+  List: "list",
+} as const;
+export type CreateRerankObject = ClosedEnum<typeof CreateRerankObject>;
+
+/**
+ * The object type, which is always `rerank`.
+ */
+export const CreateRerankRouterRerankObject = {
+  Rerank: "rerank",
+} as const;
+/**
+ * The object type, which is always `rerank`.
+ */
+export type CreateRerankRouterRerankObject = ClosedEnum<
+  typeof CreateRerankRouterRerankObject
+>;
+
+/**
+ * If return_documents is set as false this will return none, if true it will return the documents passed in
+ */
+export type CreateRerankDocument = {
+  /**
+   * The text of the document to rerank
+   */
+  text: string;
+};
+
+export type CreateRerankResults = {
+  /**
+   * The object type, which is always `rerank`.
+   */
+  object: CreateRerankRouterRerankObject;
+  /**
+   * Corresponds to the index in the original list of documents to which the ranked document belongs.
+   */
+  index: number;
+  /**
+   * Relevance scores are normalized to be in the range [0, 1]. Scores close to 1 indicate a high relevance to the query, and scores closer to 0 indicate low relevance.
+   */
+  relevanceScore: number;
+  /**
+   * If return_documents is set as false this will return none, if true it will return the documents passed in
+   */
+  document?: CreateRerankDocument | undefined;
+};
+
+export type CreateRerankUsage = {
+  /**
+   * The total number of tokens used in the rerank
+   */
+  totalTokens: number;
+};
+
+/**
+ * Returns the reranked documents.
+ */
+export type CreateRerankResponseBody = {
+  /**
+   * A unique identifier for the rerank.
+   */
+  id?: string | undefined;
+  object: CreateRerankObject;
+  /**
+   * An ordered list of ranked documents
+   */
+  results: Array<CreateRerankResults>;
+  usage?: CreateRerankUsage | undefined;
+};
+
+/** @internal */
+export type CreateRerankFallbacks$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const CreateRerankFallbacks$outboundSchema: z.ZodType<
+  CreateRerankFallbacks$Outbound,
+  z.ZodTypeDef,
+  CreateRerankFallbacks
+> = z.object({
+  model: z.string(),
+});
+
+export function createRerankFallbacksToJSON(
+  createRerankFallbacks: CreateRerankFallbacks,
+): string {
+  return JSON.stringify(
+    CreateRerankFallbacks$outboundSchema.parse(createRerankFallbacks),
+  );
+}
+
+/** @internal */
+export type CreateRerankRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
+
+/** @internal */
+export const CreateRerankRetry$outboundSchema: z.ZodType<
+  CreateRerankRetry$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRetry
+> = z.object({
+  count: z.number().default(3),
+  onCodes: z.array(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    onCodes: "on_codes",
+  });
+});
+
+export function createRerankRetryToJSON(
+  createRerankRetry: CreateRerankRetry,
+): string {
+  return JSON.stringify(
+    CreateRerankRetry$outboundSchema.parse(createRerankRetry),
+  );
+}
+
+/** @internal */
+export const CreateRerankType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateRerankType
+> = z.nativeEnum(CreateRerankType);
+
+/** @internal */
+export type CreateRerankCache$Outbound = {
+  ttl: number;
+  type: string;
+};
+
+/** @internal */
+export const CreateRerankCache$outboundSchema: z.ZodType<
+  CreateRerankCache$Outbound,
+  z.ZodTypeDef,
+  CreateRerankCache
+> = z.object({
+  ttl: z.number().default(1800),
+  type: CreateRerankType$outboundSchema,
+});
+
+export function createRerankCacheToJSON(
+  createRerankCache: CreateRerankCache,
+): string {
+  return JSON.stringify(
+    CreateRerankCache$outboundSchema.parse(createRerankCache),
+  );
+}
+
+/** @internal */
+export const CreateRerankLoadBalancerType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateRerankLoadBalancerType
+> = z.nativeEnum(CreateRerankLoadBalancerType);
+
+/** @internal */
+export type CreateRerankLoadBalancerModels$Outbound = {
+  model: string;
+  weight: number;
+};
+
+/** @internal */
+export const CreateRerankLoadBalancerModels$outboundSchema: z.ZodType<
+  CreateRerankLoadBalancerModels$Outbound,
+  z.ZodTypeDef,
+  CreateRerankLoadBalancerModels
+> = z.object({
+  model: z.string(),
+  weight: z.number().default(0.5),
+});
+
+export function createRerankLoadBalancerModelsToJSON(
+  createRerankLoadBalancerModels: CreateRerankLoadBalancerModels,
+): string {
+  return JSON.stringify(
+    CreateRerankLoadBalancerModels$outboundSchema.parse(
+      createRerankLoadBalancerModels,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateRerankLoadBalancer1$Outbound = {
+  type: string;
+  models: Array<CreateRerankLoadBalancerModels$Outbound>;
+};
+
+/** @internal */
+export const CreateRerankLoadBalancer1$outboundSchema: z.ZodType<
+  CreateRerankLoadBalancer1$Outbound,
+  z.ZodTypeDef,
+  CreateRerankLoadBalancer1
+> = z.object({
+  type: CreateRerankLoadBalancerType$outboundSchema,
+  models: z.array(z.lazy(() => CreateRerankLoadBalancerModels$outboundSchema)),
+});
+
+export function createRerankLoadBalancer1ToJSON(
+  createRerankLoadBalancer1: CreateRerankLoadBalancer1,
+): string {
+  return JSON.stringify(
+    CreateRerankLoadBalancer1$outboundSchema.parse(createRerankLoadBalancer1),
+  );
+}
+
+/** @internal */
+export type CreateRerankLoadBalancer$Outbound =
+  CreateRerankLoadBalancer1$Outbound;
+
+/** @internal */
+export const CreateRerankLoadBalancer$outboundSchema: z.ZodType<
+  CreateRerankLoadBalancer$Outbound,
+  z.ZodTypeDef,
+  CreateRerankLoadBalancer
+> = z.lazy(() => CreateRerankLoadBalancer1$outboundSchema);
+
+export function createRerankLoadBalancerToJSON(
+  createRerankLoadBalancer: CreateRerankLoadBalancer,
+): string {
+  return JSON.stringify(
+    CreateRerankLoadBalancer$outboundSchema.parse(createRerankLoadBalancer),
+  );
+}
+
+/** @internal */
+export type CreateRerankTimeout$Outbound = {
+  call_timeout: number;
+};
+
+/** @internal */
+export const CreateRerankTimeout$outboundSchema: z.ZodType<
+  CreateRerankTimeout$Outbound,
+  z.ZodTypeDef,
+  CreateRerankTimeout
+> = z.object({
+  callTimeout: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    callTimeout: "call_timeout",
+  });
+});
+
+export function createRerankTimeoutToJSON(
+  createRerankTimeout: CreateRerankTimeout,
+): string {
+  return JSON.stringify(
+    CreateRerankTimeout$outboundSchema.parse(createRerankTimeout),
+  );
+}
+
+/** @internal */
+export type CreateRerankRouterRerankFallbacks$Outbound = {
+  model: string;
+};
+
+/** @internal */
+export const CreateRerankRouterRerankFallbacks$outboundSchema: z.ZodType<
+  CreateRerankRouterRerankFallbacks$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRouterRerankFallbacks
+> = z.object({
+  model: z.string(),
+});
+
+export function createRerankRouterRerankFallbacksToJSON(
+  createRerankRouterRerankFallbacks: CreateRerankRouterRerankFallbacks,
+): string {
+  return JSON.stringify(
+    CreateRerankRouterRerankFallbacks$outboundSchema.parse(
+      createRerankRouterRerankFallbacks,
+    ),
+  );
+}
+
+/** @internal */
+export const CreateRerankRouterRerankType$outboundSchema: z.ZodNativeEnum<
+  typeof CreateRerankRouterRerankType
+> = z.nativeEnum(CreateRerankRouterRerankType);
+
+/** @internal */
+export type CreateRerankRouterRerankCache$Outbound = {
+  ttl: number;
+  type: string;
+};
+
+/** @internal */
+export const CreateRerankRouterRerankCache$outboundSchema: z.ZodType<
+  CreateRerankRouterRerankCache$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRouterRerankCache
+> = z.object({
+  ttl: z.number().default(1800),
+  type: CreateRerankRouterRerankType$outboundSchema,
+});
+
+export function createRerankRouterRerankCacheToJSON(
+  createRerankRouterRerankCache: CreateRerankRouterRerankCache,
+): string {
+  return JSON.stringify(
+    CreateRerankRouterRerankCache$outboundSchema.parse(
+      createRerankRouterRerankCache,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateRerankRouterRerankRetry$Outbound = {
+  count: number;
+  on_codes?: Array<number> | undefined;
+};
+
+/** @internal */
+export const CreateRerankRouterRerankRetry$outboundSchema: z.ZodType<
+  CreateRerankRouterRerankRetry$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRouterRerankRetry
+> = z.object({
+  count: z.number().default(3),
+  onCodes: z.array(z.number()).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    onCodes: "on_codes",
+  });
+});
+
+export function createRerankRouterRerankRetryToJSON(
+  createRerankRouterRerankRetry: CreateRerankRouterRerankRetry,
+): string {
+  return JSON.stringify(
+    CreateRerankRouterRerankRetry$outboundSchema.parse(
+      createRerankRouterRerankRetry,
+    ),
+  );
+}
+
+/** @internal */
+export const CreateRerankLoadBalancerRouterRerankType$outboundSchema:
+  z.ZodNativeEnum<typeof CreateRerankLoadBalancerRouterRerankType> = z
+    .nativeEnum(CreateRerankLoadBalancerRouterRerankType);
+
+/** @internal */
+export type CreateRerankLoadBalancerRouterRerankModels$Outbound = {
+  model: string;
+  weight: number;
+};
+
+/** @internal */
+export const CreateRerankLoadBalancerRouterRerankModels$outboundSchema:
+  z.ZodType<
+    CreateRerankLoadBalancerRouterRerankModels$Outbound,
+    z.ZodTypeDef,
+    CreateRerankLoadBalancerRouterRerankModels
+  > = z.object({
+    model: z.string(),
+    weight: z.number().default(0.5),
+  });
+
+export function createRerankLoadBalancerRouterRerankModelsToJSON(
+  createRerankLoadBalancerRouterRerankModels:
+    CreateRerankLoadBalancerRouterRerankModels,
+): string {
+  return JSON.stringify(
+    CreateRerankLoadBalancerRouterRerankModels$outboundSchema.parse(
+      createRerankLoadBalancerRouterRerankModels,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateRerankLoadBalancerRouterRerank1$Outbound = {
+  type: string;
+  models: Array<CreateRerankLoadBalancerRouterRerankModels$Outbound>;
+};
+
+/** @internal */
+export const CreateRerankLoadBalancerRouterRerank1$outboundSchema: z.ZodType<
+  CreateRerankLoadBalancerRouterRerank1$Outbound,
+  z.ZodTypeDef,
+  CreateRerankLoadBalancerRouterRerank1
+> = z.object({
+  type: CreateRerankLoadBalancerRouterRerankType$outboundSchema,
+  models: z.array(
+    z.lazy(() => CreateRerankLoadBalancerRouterRerankModels$outboundSchema),
+  ),
+});
+
+export function createRerankLoadBalancerRouterRerank1ToJSON(
+  createRerankLoadBalancerRouterRerank1: CreateRerankLoadBalancerRouterRerank1,
+): string {
+  return JSON.stringify(
+    CreateRerankLoadBalancerRouterRerank1$outboundSchema.parse(
+      createRerankLoadBalancerRouterRerank1,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateRerankRouterRerankLoadBalancer$Outbound =
+  CreateRerankLoadBalancerRouterRerank1$Outbound;
+
+/** @internal */
+export const CreateRerankRouterRerankLoadBalancer$outboundSchema: z.ZodType<
+  CreateRerankRouterRerankLoadBalancer$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRouterRerankLoadBalancer
+> = z.lazy(() => CreateRerankLoadBalancerRouterRerank1$outboundSchema);
+
+export function createRerankRouterRerankLoadBalancerToJSON(
+  createRerankRouterRerankLoadBalancer: CreateRerankRouterRerankLoadBalancer,
+): string {
+  return JSON.stringify(
+    CreateRerankRouterRerankLoadBalancer$outboundSchema.parse(
+      createRerankRouterRerankLoadBalancer,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateRerankRouterRerankTimeout$Outbound = {
+  call_timeout: number;
+};
+
+/** @internal */
+export const CreateRerankRouterRerankTimeout$outboundSchema: z.ZodType<
+  CreateRerankRouterRerankTimeout$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRouterRerankTimeout
+> = z.object({
+  callTimeout: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    callTimeout: "call_timeout",
+  });
+});
+
+export function createRerankRouterRerankTimeoutToJSON(
+  createRerankRouterRerankTimeout: CreateRerankRouterRerankTimeout,
+): string {
+  return JSON.stringify(
+    CreateRerankRouterRerankTimeout$outboundSchema.parse(
+      createRerankRouterRerankTimeout,
+    ),
+  );
+}
+
+/** @internal */
+export type CreateRerankOrq$Outbound = {
+  name?: string | undefined;
+  fallbacks?: Array<CreateRerankRouterRerankFallbacks$Outbound> | undefined;
+  cache?: CreateRerankRouterRerankCache$Outbound | undefined;
+  retry?: CreateRerankRouterRerankRetry$Outbound | undefined;
+  identity?: components.PublicIdentity$Outbound | undefined;
+  contact?: components.PublicContact$Outbound | undefined;
+  load_balancer?: CreateRerankLoadBalancerRouterRerank1$Outbound | undefined;
+  timeout?: CreateRerankRouterRerankTimeout$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateRerankOrq$outboundSchema: z.ZodType<
+  CreateRerankOrq$Outbound,
+  z.ZodTypeDef,
+  CreateRerankOrq
+> = z.object({
+  name: z.string().optional(),
+  fallbacks: z.array(
+    z.lazy(() => CreateRerankRouterRerankFallbacks$outboundSchema),
+  ).optional(),
+  cache: z.lazy(() => CreateRerankRouterRerankCache$outboundSchema).optional(),
+  retry: z.lazy(() => CreateRerankRouterRerankRetry$outboundSchema).optional(),
+  identity: components.PublicIdentity$outboundSchema.optional(),
+  contact: components.PublicContact$outboundSchema.optional(),
+  loadBalancer: z.lazy(() =>
+    CreateRerankLoadBalancerRouterRerank1$outboundSchema
+  ).optional(),
+  timeout: z.lazy(() => CreateRerankRouterRerankTimeout$outboundSchema)
+    .optional(),
+}).transform((v) => {
+  return remap$(v, {
+    loadBalancer: "load_balancer",
+  });
+});
+
+export function createRerankOrqToJSON(
+  createRerankOrq: CreateRerankOrq,
+): string {
+  return JSON.stringify(CreateRerankOrq$outboundSchema.parse(createRerankOrq));
+}
+
+/** @internal */
+export type CreateRerankRequestBody$Outbound = {
+  query: string;
+  documents: Array<string>;
+  model: string;
+  top_n?: number | undefined;
+  filename?: string | null | undefined;
+  name?: string | undefined;
+  fallbacks?: Array<CreateRerankFallbacks$Outbound> | undefined;
+  retry?: CreateRerankRetry$Outbound | undefined;
+  cache?: CreateRerankCache$Outbound | undefined;
+  load_balancer?: CreateRerankLoadBalancer1$Outbound | undefined;
+  timeout?: CreateRerankTimeout$Outbound | undefined;
+  orq?: CreateRerankOrq$Outbound | undefined;
+};
+
+/** @internal */
+export const CreateRerankRequestBody$outboundSchema: z.ZodType<
+  CreateRerankRequestBody$Outbound,
+  z.ZodTypeDef,
+  CreateRerankRequestBody
+> = z.object({
+  query: z.string(),
+  documents: z.array(z.string()),
+  model: z.string(),
+  topN: z.number().optional(),
+  filename: z.nullable(z.string()).optional(),
+  name: z.string().optional(),
+  fallbacks: z.array(z.lazy(() => CreateRerankFallbacks$outboundSchema))
+    .optional(),
+  retry: z.lazy(() => CreateRerankRetry$outboundSchema).optional(),
+  cache: z.lazy(() => CreateRerankCache$outboundSchema).optional(),
+  loadBalancer: z.lazy(() => CreateRerankLoadBalancer1$outboundSchema)
+    .optional(),
+  timeout: z.lazy(() => CreateRerankTimeout$outboundSchema).optional(),
+  orq: z.lazy(() => CreateRerankOrq$outboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    topN: "top_n",
+    loadBalancer: "load_balancer",
+  });
+});
+
+export function createRerankRequestBodyToJSON(
+  createRerankRequestBody: CreateRerankRequestBody,
+): string {
+  return JSON.stringify(
+    CreateRerankRequestBody$outboundSchema.parse(createRerankRequestBody),
+  );
+}
+
+/** @internal */
+export const CreateRerankObject$inboundSchema: z.ZodNativeEnum<
+  typeof CreateRerankObject
+> = z.nativeEnum(CreateRerankObject);
+
+/** @internal */
+export const CreateRerankRouterRerankObject$inboundSchema: z.ZodNativeEnum<
+  typeof CreateRerankRouterRerankObject
+> = z.nativeEnum(CreateRerankRouterRerankObject);
+
+/** @internal */
+export const CreateRerankDocument$inboundSchema: z.ZodType<
+  CreateRerankDocument,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  text: z.string(),
+});
+
+export function createRerankDocumentFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRerankDocument, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRerankDocument$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRerankDocument' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateRerankResults$inboundSchema: z.ZodType<
+  CreateRerankResults,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  object: CreateRerankRouterRerankObject$inboundSchema,
+  index: z.number(),
+  relevance_score: z.number(),
+  document: z.lazy(() => CreateRerankDocument$inboundSchema).optional(),
+}).transform((v) => {
+  return remap$(v, {
+    "relevance_score": "relevanceScore",
+  });
+});
+
+export function createRerankResultsFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRerankResults, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRerankResults$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRerankResults' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateRerankUsage$inboundSchema: z.ZodType<
+  CreateRerankUsage,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  total_tokens: z.number(),
+}).transform((v) => {
+  return remap$(v, {
+    "total_tokens": "totalTokens",
+  });
+});
+
+export function createRerankUsageFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRerankUsage, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRerankUsage$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRerankUsage' from JSON`,
+  );
+}
+
+/** @internal */
+export const CreateRerankResponseBody$inboundSchema: z.ZodType<
+  CreateRerankResponseBody,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  id: z.string().optional(),
+  object: CreateRerankObject$inboundSchema,
+  results: z.array(z.lazy(() => CreateRerankResults$inboundSchema)),
+  usage: z.lazy(() => CreateRerankUsage$inboundSchema).optional(),
+});
+
+export function createRerankResponseBodyFromJSON(
+  jsonString: string,
+): SafeParseResult<CreateRerankResponseBody, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => CreateRerankResponseBody$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'CreateRerankResponseBody' from JSON`,
+  );
+}