/*
 * 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 { SDKValidationError } from "../errors/sdkvalidationerror.js";

export type ReinforcementHyperparametersBatchSize = string | number;

export type ComputeMultiplier = string | number;

export type EvalInterval = string | number;

export type EvalSamples = string | number;

export type ReinforcementHyperparametersLearningRateMultiplier =
  | string
  | number;

export type ReinforcementHyperparametersNEpochs = string | number;

export const ReinforcementHyperparametersReasoningEffort = {
  Default: "default",
  Low: "low",
  Medium: "medium",
  High: "high",
} as const;
export type ReinforcementHyperparametersReasoningEffort = ClosedEnum<
  typeof ReinforcementHyperparametersReasoningEffort
>;

export type ReinforcementHyperparameters = {
  /**
   * Number of examples in each batch
   */
  batchSize?: string | number | null | undefined;
  /**
   * Scales compute for exploration during training
   */
  computeMultiplier?: string | number | null | undefined;
  /**
   * Number of steps between evaluations
   */
  evalInterval?: string | number | null | undefined;
  /**
   * Number of samples generated per eval step
   */
  evalSamples?: string | number | null | undefined;
  /**
   * Scaling factor for learning rate
   */
  learningRateMultiplier?: string | number | null | undefined;
  /**
   * Number of epochs to train for
   */
  nEpochs?: string | number | null | undefined;
  /**
   * Reasoning effort level
   */
  reasoningEffort?:
    | ReinforcementHyperparametersReasoningEffort
    | null
    | undefined;
};

/** @internal */
export const ReinforcementHyperparametersBatchSize$inboundSchema: z.ZodType<
  ReinforcementHyperparametersBatchSize,
  z.ZodTypeDef,
  unknown
> = z.union([z.string(), z.number().int()]);
/** @internal */
export type ReinforcementHyperparametersBatchSize$Outbound = string | number;

/** @internal */
export const ReinforcementHyperparametersBatchSize$outboundSchema: z.ZodType<
  ReinforcementHyperparametersBatchSize$Outbound,
  z.ZodTypeDef,
  ReinforcementHyperparametersBatchSize
> = z.union([z.string(), z.number().int()]);

export function reinforcementHyperparametersBatchSizeToJSON(
  reinforcementHyperparametersBatchSize: ReinforcementHyperparametersBatchSize,
): string {
  return JSON.stringify(
    ReinforcementHyperparametersBatchSize$outboundSchema.parse(
      reinforcementHyperparametersBatchSize,
    ),
  );
}
export function reinforcementHyperparametersBatchSizeFromJSON(
  jsonString: string,
): SafeParseResult<ReinforcementHyperparametersBatchSize, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ReinforcementHyperparametersBatchSize$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ReinforcementHyperparametersBatchSize' from JSON`,
  );
}

/** @internal */
export const ComputeMultiplier$inboundSchema: z.ZodType<
  ComputeMultiplier,
  z.ZodTypeDef,
  unknown
> = z.union([z.string(), z.number()]);
/** @internal */
export type ComputeMultiplier$Outbound = string | number;

/** @internal */
export const ComputeMultiplier$outboundSchema: z.ZodType<
  ComputeMultiplier$Outbound,
  z.ZodTypeDef,
  ComputeMultiplier
> = z.union([z.string(), z.number()]);

export function computeMultiplierToJSON(
  computeMultiplier: ComputeMultiplier,
): string {
  return JSON.stringify(
    ComputeMultiplier$outboundSchema.parse(computeMultiplier),
  );
}
export function computeMultiplierFromJSON(
  jsonString: string,
): SafeParseResult<ComputeMultiplier, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ComputeMultiplier$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ComputeMultiplier' from JSON`,
  );
}

/** @internal */
export const EvalInterval$inboundSchema: z.ZodType<
  EvalInterval,
  z.ZodTypeDef,
  unknown
> = z.union([z.string(), z.number().int()]);
/** @internal */
export type EvalInterval$Outbound = string | number;

/** @internal */
export const EvalInterval$outboundSchema: z.ZodType<
  EvalInterval$Outbound,
  z.ZodTypeDef,
  EvalInterval
> = z.union([z.string(), z.number().int()]);

export function evalIntervalToJSON(evalInterval: EvalInterval): string {
  return JSON.stringify(EvalInterval$outboundSchema.parse(evalInterval));
}
export function evalIntervalFromJSON(
  jsonString: string,
): SafeParseResult<EvalInterval, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => EvalInterval$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'EvalInterval' from JSON`,
  );
}

/** @internal */
export const EvalSamples$inboundSchema: z.ZodType<
  EvalSamples,
  z.ZodTypeDef,
  unknown
> = z.union([z.string(), z.number().int()]);
/** @internal */
export type EvalSamples$Outbound = string | number;

/** @internal */
export const EvalSamples$outboundSchema: z.ZodType<
  EvalSamples$Outbound,
  z.ZodTypeDef,
  EvalSamples
> = z.union([z.string(), z.number().int()]);

export function evalSamplesToJSON(evalSamples: EvalSamples): string {
  return JSON.stringify(EvalSamples$outboundSchema.parse(evalSamples));
}
export function evalSamplesFromJSON(
  jsonString: string,
): SafeParseResult<EvalSamples, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => EvalSamples$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'EvalSamples' from JSON`,
  );
}

/** @internal */
export const ReinforcementHyperparametersLearningRateMultiplier$inboundSchema:
  z.ZodType<
    ReinforcementHyperparametersLearningRateMultiplier,
    z.ZodTypeDef,
    unknown
  > = z.union([z.string(), z.number()]);
/** @internal */
export type ReinforcementHyperparametersLearningRateMultiplier$Outbound =
  | string
  | number;

/** @internal */
export const ReinforcementHyperparametersLearningRateMultiplier$outboundSchema:
  z.ZodType<
    ReinforcementHyperparametersLearningRateMultiplier$Outbound,
    z.ZodTypeDef,
    ReinforcementHyperparametersLearningRateMultiplier
  > = z.union([z.string(), z.number()]);

export function reinforcementHyperparametersLearningRateMultiplierToJSON(
  reinforcementHyperparametersLearningRateMultiplier:
    ReinforcementHyperparametersLearningRateMultiplier,
): string {
  return JSON.stringify(
    ReinforcementHyperparametersLearningRateMultiplier$outboundSchema.parse(
      reinforcementHyperparametersLearningRateMultiplier,
    ),
  );
}
export function reinforcementHyperparametersLearningRateMultiplierFromJSON(
  jsonString: string,
): SafeParseResult<
  ReinforcementHyperparametersLearningRateMultiplier,
  SDKValidationError
> {
  return safeParse(
    jsonString,
    (x) =>
      ReinforcementHyperparametersLearningRateMultiplier$inboundSchema.parse(
        JSON.parse(x),
      ),
    `Failed to parse 'ReinforcementHyperparametersLearningRateMultiplier' from JSON`,
  );
}

/** @internal */
export const ReinforcementHyperparametersNEpochs$inboundSchema: z.ZodType<
  ReinforcementHyperparametersNEpochs,
  z.ZodTypeDef,
  unknown
> = z.union([z.string(), z.number().int()]);
/** @internal */
export type ReinforcementHyperparametersNEpochs$Outbound = string | number;

/** @internal */
export const ReinforcementHyperparametersNEpochs$outboundSchema: z.ZodType<
  ReinforcementHyperparametersNEpochs$Outbound,
  z.ZodTypeDef,
  ReinforcementHyperparametersNEpochs
> = z.union([z.string(), z.number().int()]);

export function reinforcementHyperparametersNEpochsToJSON(
  reinforcementHyperparametersNEpochs: ReinforcementHyperparametersNEpochs,
): string {
  return JSON.stringify(
    ReinforcementHyperparametersNEpochs$outboundSchema.parse(
      reinforcementHyperparametersNEpochs,
    ),
  );
}
export function reinforcementHyperparametersNEpochsFromJSON(
  jsonString: string,
): SafeParseResult<ReinforcementHyperparametersNEpochs, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) =>
      ReinforcementHyperparametersNEpochs$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ReinforcementHyperparametersNEpochs' from JSON`,
  );
}

/** @internal */
export const ReinforcementHyperparametersReasoningEffort$inboundSchema:
  z.ZodNativeEnum<typeof ReinforcementHyperparametersReasoningEffort> = z
    .nativeEnum(ReinforcementHyperparametersReasoningEffort);
/** @internal */
export const ReinforcementHyperparametersReasoningEffort$outboundSchema:
  z.ZodNativeEnum<typeof ReinforcementHyperparametersReasoningEffort> =
    ReinforcementHyperparametersReasoningEffort$inboundSchema;

/** @internal */
export const ReinforcementHyperparameters$inboundSchema: z.ZodType<
  ReinforcementHyperparameters,
  z.ZodTypeDef,
  unknown
> = z.object({
  batch_size: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  compute_multiplier: z.nullable(z.union([z.string(), z.number()])).optional(),
  eval_interval: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  eval_samples: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  learning_rate_multiplier: z.nullable(z.union([z.string(), z.number()]))
    .optional(),
  n_epochs: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  reasoning_effort: z.nullable(
    ReinforcementHyperparametersReasoningEffort$inboundSchema,
  ).optional(),
}).transform((v) => {
  return remap$(v, {
    "batch_size": "batchSize",
    "compute_multiplier": "computeMultiplier",
    "eval_interval": "evalInterval",
    "eval_samples": "evalSamples",
    "learning_rate_multiplier": "learningRateMultiplier",
    "n_epochs": "nEpochs",
    "reasoning_effort": "reasoningEffort",
  });
});
/** @internal */
export type ReinforcementHyperparameters$Outbound = {
  batch_size?: string | number | null | undefined;
  compute_multiplier?: string | number | null | undefined;
  eval_interval?: string | number | null | undefined;
  eval_samples?: string | number | null | undefined;
  learning_rate_multiplier?: string | number | null | undefined;
  n_epochs?: string | number | null | undefined;
  reasoning_effort?: string | null | undefined;
};

/** @internal */
export const ReinforcementHyperparameters$outboundSchema: z.ZodType<
  ReinforcementHyperparameters$Outbound,
  z.ZodTypeDef,
  ReinforcementHyperparameters
> = z.object({
  batchSize: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  computeMultiplier: z.nullable(z.union([z.string(), z.number()])).optional(),
  evalInterval: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  evalSamples: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  learningRateMultiplier: z.nullable(z.union([z.string(), z.number()]))
    .optional(),
  nEpochs: z.nullable(z.union([z.string(), z.number().int()])).optional(),
  reasoningEffort: z.nullable(
    ReinforcementHyperparametersReasoningEffort$outboundSchema,
  ).optional(),
}).transform((v) => {
  return remap$(v, {
    batchSize: "batch_size",
    computeMultiplier: "compute_multiplier",
    evalInterval: "eval_interval",
    evalSamples: "eval_samples",
    learningRateMultiplier: "learning_rate_multiplier",
    nEpochs: "n_epochs",
    reasoningEffort: "reasoning_effort",
  });
});

export function reinforcementHyperparametersToJSON(
  reinforcementHyperparameters: ReinforcementHyperparameters,
): string {
  return JSON.stringify(
    ReinforcementHyperparameters$outboundSchema.parse(
      reinforcementHyperparameters,
    ),
  );
}
export function reinforcementHyperparametersFromJSON(
  jsonString: string,
): SafeParseResult<ReinforcementHyperparameters, SDKValidationError> {
  return safeParse(
    jsonString,
    (x) => ReinforcementHyperparameters$inboundSchema.parse(JSON.parse(x)),
    `Failed to parse 'ReinforcementHyperparameters' from JSON`,
  );
}