@launchdarkly/mcp-server 0.7.1 → 0.7.2

package/src/models/components/aiconfigvariationpatch.ts

@@ -4,8 +4,15 @@
 
 import * as z from "zod/v3";
 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";
+import {
+  Classifier,
+  Classifier$inboundSchema,
+  Classifier$Outbound,
+  Classifier$outboundSchema,
+} from "./classifier.js";
 import {
   JudgeConfiguration,
   JudgeConfiguration$inboundSchema,
@@ -18,6 +25,12 @@ import {
   Message$Outbound,
   Message$outboundSchema,
 } from "./message.js";
+import {
+  VariationSkillPost,
+  VariationSkillPost$inboundSchema,
+  VariationSkillPost$Outbound,
+  VariationSkillPost$outboundSchema,
+} from "./variationskillpost.js";
 import {
   VariationToolPost,
   VariationToolPost$inboundSchema,
@@ -25,30 +38,98 @@ import {
   VariationToolPost$outboundSchema,
 } from "./variationtoolpost.js";
 
+/**
+ * Freeform JSON object. LaunchDarkly does not validate the keys. In a model config, `params` and `customParams` hold parameters that the provider's API accepts, for example `{"temperature": 0.7, "maxTokens": 4096}`.
+ */
 export type AIConfigVariationPatchModel = {};
 
+/**
+ * The state to move the variation to. Omit this field to keep the current state.
+ *
+ * @remarks
+ * - `archived`: Archive a published variation. You cannot archive a variation that is already archived. You also cannot archive the only variation of an AI Config. An AI Config itself cannot be archived.
+ * - `published`: Restore an archived variation. You cannot publish a variation that is already published.
+ */
+export const AIConfigVariationPatchState = {
+  Archived: "archived",
+  Published: "published",
+} as const;
+/**
+ * The state to move the variation to. Omit this field to keep the current state.
+ *
+ * @remarks
+ * - `archived`: Archive a published variation. You cannot archive a variation that is already archived. You also cannot archive the only variation of an AI Config. An AI Config itself cannot be archived.
+ * - `published`: Restore an archived variation. You cannot publish a variation that is already published.
+ */
+export type AIConfigVariationPatchState = ClosedEnum<
+  typeof AIConfigVariationPatchState
+>;
+
 export type AIConfigVariationPatch = {
+  /**
+   * Replaces classifier rules on a judge variation. An empty array clears them. When this array is
+   *
+   * @remarks
+   * non-empty, messages must be empty.
+   */
+  classifiers?: Array<Classifier> | undefined;
   /**
    * Human-readable description of what this patch changes
    */
   comment?: string | undefined;
   /**
-   * Description for agent when AI Config is in agent mode.
+   * Description for agent when the config is in agent mode.
    */
   description?: string | undefined;
   /**
-   * Instructions for agent when AI Config is in agent mode.
+   * Instructions for agent when the config is in agent mode.
    */
   instructions?: string | undefined;
+  /**
+   * The prompt messages for this variation
+   */
   messages?: Array<Message> | undefined;
+  /**
+   * Freeform JSON object. LaunchDarkly does not validate the keys. In a model config, `params` and `customParams` hold parameters that the provider's API accepts, for example `{"temperature": 0.7, "maxTokens": 4096}`.
+   */
   model?: AIConfigVariationPatchModel | undefined;
+  /**
+   * The key that GET /api/v2/projects/{projectKey}/ai-configs/model-configs returns for the
+   *
+   * @remarks
+   * model config. Do not use a custom model config's ID, which is the provider model ID.
+   */
   modelConfigKey?: string | undefined;
+  /**
+   * The exact model config version to set this variation to. Requires modelConfigKey to be
+   *
+   * @remarks
+   * set (either in this patch or already on the variation), and the version must exist for
+   * that model config. When omitted, the variation keeps the version it is currently set to,
+   * unless the patch changes modelConfigKey, in which case the variation records the new
+   * model config's current (latest) version.
+   */
+  modelConfigVersion?: number | undefined;
+  /**
+   * A human-readable name for the variation
+   */
   name?: string | undefined;
+  /**
+   * JSON Schema defining the structured output format for the variation.
+   */
+  outputFormat?: { [k: string]: any } | undefined;
+  /**
+   * Whether to publish this version of the variation
+   */
   published?: boolean | undefined;
   /**
-   * One of 'archived', 'published'
+   * The state to move the variation to. Omit this field to keep the current state.
+   *
+   * @remarks
+   * - `archived`: Archive a published variation. You cannot archive a variation that is already archived. You also cannot archive the only variation of an AI Config. An AI Config itself cannot be archived.
+   * - `published`: Restore an archived variation. You cannot publish a variation that is already published.
    */
-  state?: string | undefined;
+  state?: AIConfigVariationPatchState | undefined;
   /**
    * List of tools to use for this variation. The latest version of the tool will be used.
    */
@@ -57,6 +138,10 @@ export type AIConfigVariationPatch = {
    * List of tool keys to use for this variation. The latest version of the tool will be used.
    */
   toolKeys?: Array<string> | undefined;
+  /**
+   * List of agent skills to attach to this variation. Replaces the current attachments.
+   */
+  skills?: Array<VariationSkillPost> | undefined;
   judgeConfiguration?: JudgeConfiguration | undefined;
 };
 
@@ -95,38 +180,55 @@ export function aiConfigVariationPatchModelFromJSON(
   );
 }
 
+/** @internal */
+export const AIConfigVariationPatchState$inboundSchema: z.ZodNativeEnum<
+  typeof AIConfigVariationPatchState
+> = z.nativeEnum(AIConfigVariationPatchState);
+/** @internal */
+export const AIConfigVariationPatchState$outboundSchema: z.ZodNativeEnum<
+  typeof AIConfigVariationPatchState
+> = AIConfigVariationPatchState$inboundSchema;
+
 /** @internal */
 export const AIConfigVariationPatch$inboundSchema: z.ZodType<
   AIConfigVariationPatch,
   z.ZodTypeDef,
   unknown
 > = z.object({
+  classifiers: z.array(Classifier$inboundSchema).optional(),
   comment: z.string().optional(),
   description: z.string().optional(),
   instructions: z.string().optional(),
   messages: z.array(Message$inboundSchema).optional(),
   model: z.lazy(() => AIConfigVariationPatchModel$inboundSchema).optional(),
   modelConfigKey: z.string().optional(),
+  modelConfigVersion: z.number().int().optional(),
   name: z.string().optional(),
+  outputFormat: z.record(z.any()).optional(),
   published: z.boolean().optional(),
-  state: z.string().optional(),
+  state: AIConfigVariationPatchState$inboundSchema.optional(),
   tools: z.array(VariationToolPost$inboundSchema).optional(),
   toolKeys: z.array(z.string()).optional(),
+  skills: z.array(VariationSkillPost$inboundSchema).optional(),
   judgeConfiguration: JudgeConfiguration$inboundSchema.optional(),
 });
 /** @internal */
 export type AIConfigVariationPatch$Outbound = {
+  classifiers?: Array<Classifier$Outbound> | undefined;
   comment?: string | undefined;
   description?: string | undefined;
   instructions?: string | undefined;
   messages?: Array<Message$Outbound> | undefined;
   model?: AIConfigVariationPatchModel$Outbound | undefined;
   modelConfigKey?: string | undefined;
+  modelConfigVersion?: number | undefined;
   name?: string | undefined;
+  outputFormat?: { [k: string]: any } | undefined;
   published?: boolean | undefined;
   state?: string | undefined;
   tools?: Array<VariationToolPost$Outbound> | undefined;
   toolKeys?: Array<string> | undefined;
+  skills?: Array<VariationSkillPost$Outbound> | undefined;
   judgeConfiguration?: JudgeConfiguration$Outbound | undefined;
 };
 
@@ -136,17 +238,21 @@ export const AIConfigVariationPatch$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AIConfigVariationPatch
 > = z.object({
+  classifiers: z.array(Classifier$outboundSchema).optional(),
   comment: z.string().optional(),
   description: z.string().optional(),
   instructions: z.string().optional(),
   messages: z.array(Message$outboundSchema).optional(),
   model: z.lazy(() => AIConfigVariationPatchModel$outboundSchema).optional(),
   modelConfigKey: z.string().optional(),
+  modelConfigVersion: z.number().int().optional(),
   name: z.string().optional(),
+  outputFormat: z.record(z.any()).optional(),
   published: z.boolean().optional(),
-  state: z.string().optional(),
+  state: AIConfigVariationPatchState$outboundSchema.optional(),
   tools: z.array(VariationToolPost$outboundSchema).optional(),
   toolKeys: z.array(z.string()).optional(),
+  skills: z.array(VariationSkillPost$outboundSchema).optional(),
   judgeConfiguration: JudgeConfiguration$outboundSchema.optional(),
 });
 

package/src/models/components/aiconfigvariationpost.ts

@@ -6,6 +6,12 @@ import * as z from "zod/v3";
 import { safeParse } from "../../lib/schemas.js";
 import { Result as SafeParseResult } from "../../types/fp.js";
 import { SDKValidationError } from "../errors/sdkvalidationerror.js";
+import {
+  Classifier,
+  Classifier$inboundSchema,
+  Classifier$Outbound,
+  Classifier$outboundSchema,
+} from "./classifier.js";
 import {
   JudgeConfiguration,
   JudgeConfiguration$inboundSchema,
@@ -18,6 +24,12 @@ import {
   Message$Outbound,
   Message$outboundSchema,
 } from "./message.js";
+import {
+  VariationSkillPost,
+  VariationSkillPost$inboundSchema,
+  VariationSkillPost$Outbound,
+  VariationSkillPost$outboundSchema,
+} from "./variationskillpost.js";
 import {
   VariationToolPost,
   VariationToolPost$inboundSchema,
@@ -25,9 +37,18 @@ import {
   VariationToolPost$outboundSchema,
 } from "./variationtoolpost.js";
 
+/**
+ * Freeform JSON object. LaunchDarkly does not validate the keys. In a model config, `params` and `customParams` hold parameters that the provider's API accepts, for example `{"temperature": 0.7, "maxTokens": 4096}`.
+ */
 export type AIConfigVariationPostModel = {};
 
 export type AIConfigVariationPost = {
+  /**
+   * Classifier rules for a judge variation. When this array is non-empty, messages must be empty.
+   *
+   * @remarks
+   */
+  classifiers?: Array<Classifier> | undefined;
   /**
    * Human-readable description of this variation
    */
@@ -40,11 +61,41 @@ export type AIConfigVariationPost = {
    * Returns the instructions for the agent. This is only returned for agent variations.
    */
   instructions?: string | undefined;
+  /**
+   * A unique key for the variation
+   */
   key: string;
+  /**
+   * The prompt messages for this variation
+   */
   messages?: Array<Message> | undefined;
+  /**
+   * Freeform JSON object. LaunchDarkly does not validate the keys. In a model config, `params` and `customParams` hold parameters that the provider's API accepts, for example `{"temperature": 0.7, "maxTokens": 4096}`.
+   */
   model?: AIConfigVariationPostModel | undefined;
+  /**
+   * A human-readable name for the variation
+   */
   name: string;
+  /**
+   * The key that GET /api/v2/projects/{projectKey}/ai-configs/model-configs returns for the
+   *
+   * @remarks
+   * model config. Do not use a custom model config's ID, which is the provider model ID.
+   */
   modelConfigKey?: string | undefined;
+  /**
+   * The exact model config version to set this variation to. Requires modelConfigKey to be
+   *
+   * @remarks
+   * set, and the version must exist for that model config. When omitted, the variation
+   * records the model config's current (latest) version.
+   */
+  modelConfigVersion?: number | undefined;
+  /**
+   * JSON Schema defining the structured output format for the variation.
+   */
+  outputFormat?: { [k: string]: any } | undefined;
   /**
    * List of tools to use for this variation. The latest version of the tool will be used.
    */
@@ -53,6 +104,10 @@ export type AIConfigVariationPost = {
    * List of tool keys to use for this variation. The latest version of the tool will be used.
    */
   toolKeys?: Array<string> | undefined;
+  /**
+   * List of agent skills to attach to this variation.
+   */
+  skills?: Array<VariationSkillPost> | undefined;
   judgeConfiguration?: JudgeConfiguration | undefined;
 };
 
@@ -95,6 +150,7 @@ export const AIConfigVariationPost$inboundSchema: z.ZodType<
   z.ZodTypeDef,
   unknown
 > = z.object({
+  classifiers: z.array(Classifier$inboundSchema).optional(),
   comment: z.string().optional(),
   description: z.string().optional(),
   instructions: z.string().optional(),
@@ -103,12 +159,16 @@ export const AIConfigVariationPost$inboundSchema: z.ZodType<
   model: z.lazy(() => AIConfigVariationPostModel$inboundSchema).optional(),
   name: z.string(),
   modelConfigKey: z.string().optional(),
+  modelConfigVersion: z.number().int().optional(),
+  outputFormat: z.record(z.any()).optional(),
   tools: z.array(VariationToolPost$inboundSchema).optional(),
   toolKeys: z.array(z.string()).optional(),
+  skills: z.array(VariationSkillPost$inboundSchema).optional(),
   judgeConfiguration: JudgeConfiguration$inboundSchema.optional(),
 });
 /** @internal */
 export type AIConfigVariationPost$Outbound = {
+  classifiers?: Array<Classifier$Outbound> | undefined;
   comment?: string | undefined;
   description?: string | undefined;
   instructions?: string | undefined;
@@ -117,8 +177,11 @@ export type AIConfigVariationPost$Outbound = {
   model?: AIConfigVariationPostModel$Outbound | undefined;
   name: string;
   modelConfigKey?: string | undefined;
+  modelConfigVersion?: number | undefined;
+  outputFormat?: { [k: string]: any } | undefined;
   tools?: Array<VariationToolPost$Outbound> | undefined;
   toolKeys?: Array<string> | undefined;
+  skills?: Array<VariationSkillPost$Outbound> | undefined;
   judgeConfiguration?: JudgeConfiguration$Outbound | undefined;
 };
 
@@ -128,6 +191,7 @@ export const AIConfigVariationPost$outboundSchema: z.ZodType<
   z.ZodTypeDef,
   AIConfigVariationPost
 > = z.object({
+  classifiers: z.array(Classifier$outboundSchema).optional(),
   comment: z.string().optional(),
   description: z.string().optional(),
   instructions: z.string().optional(),
@@ -136,8 +200,11 @@ export const AIConfigVariationPost$outboundSchema: z.ZodType<
   model: z.lazy(() => AIConfigVariationPostModel$outboundSchema).optional(),
   name: z.string(),
   modelConfigKey: z.string().optional(),
+  modelConfigVersion: z.number().int().optional(),
+  outputFormat: z.record(z.any()).optional(),
   tools: z.array(VariationToolPost$outboundSchema).optional(),
   toolKeys: z.array(z.string()).optional(),
+  skills: z.array(VariationSkillPost$outboundSchema).optional(),
   judgeConfiguration: JudgeConfiguration$outboundSchema.optional(),
 });
 

package/src/models/components/aiconfigvariationsresponse.ts

@@ -14,7 +14,13 @@ import {
 } from "./aiconfigvariation.js";
 
 export type AIConfigVariationsResponse = {
+  /**
+   * The items on this page
+   */
   items: Array<AIConfigVariation>;
+  /**
+   * The total number of items
+   */
   totalCount: number;
 };
 

package/src/models/components/analysisconfiginput.ts

@@ -0,0 +1,151 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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";
+
+/**
+ * The method to use for multiple comparison correction.
+ */
+export const AnalysisConfigInputMultipleComparisonCorrectionMethod = {
+  Bonferroni: "bonferroni",
+  BenjaminiHochberg: "benjamini-hochberg",
+} as const;
+/**
+ * The method to use for multiple comparison correction.
+ */
+export type AnalysisConfigInputMultipleComparisonCorrectionMethod = ClosedEnum<
+  typeof AnalysisConfigInputMultipleComparisonCorrectionMethod
+>;
+
+/**
+ * The scope of the multiple comparison correction.
+ */
+export const AnalysisConfigInputMultipleComparisonCorrectionScope = {
+  Variations: "variations",
+  VariationsAndMetrics: "variations-and-metrics",
+  Metrics: "metrics",
+} as const;
+/**
+ * The scope of the multiple comparison correction.
+ */
+export type AnalysisConfigInputMultipleComparisonCorrectionScope = ClosedEnum<
+  typeof AnalysisConfigInputMultipleComparisonCorrectionScope
+>;
+
+export type AnalysisConfigInput = {
+  /**
+   * The threshold for the Probability to Beat Baseline (PBBL) and Probability to Be Best (PBB) comparisons for the Bayesian results analysis approach.
+   */
+  bayesianThreshold?: string | undefined;
+  /**
+   * The significance threshold for the frequentist results analysis approach.
+   */
+  significanceThreshold?: string | undefined;
+  /**
+   * The test sided direction for the frequentist results analysis approach.
+   */
+  testDirection?: string | undefined;
+  /**
+   * The method to use for multiple comparison correction.
+   */
+  multipleComparisonCorrectionMethod?:
+    | AnalysisConfigInputMultipleComparisonCorrectionMethod
+    | undefined;
+  /**
+   * The scope of the multiple comparison correction.
+   */
+  multipleComparisonCorrectionScope?:
+    | AnalysisConfigInputMultipleComparisonCorrectionScope
+    | undefined;
+  /**
+   * Whether sequential testing is enabled for Frequentist analysis
+   */
+  sequentialTestingEnabled?: boolean | undefined;
+};
+
+/** @internal */
+export const AnalysisConfigInputMultipleComparisonCorrectionMethod$inboundSchema:
+  z.ZodNativeEnum<
+    typeof AnalysisConfigInputMultipleComparisonCorrectionMethod
+  > = z.nativeEnum(AnalysisConfigInputMultipleComparisonCorrectionMethod);
+/** @internal */
+export const AnalysisConfigInputMultipleComparisonCorrectionMethod$outboundSchema:
+  z.ZodNativeEnum<
+    typeof AnalysisConfigInputMultipleComparisonCorrectionMethod
+  > = AnalysisConfigInputMultipleComparisonCorrectionMethod$inboundSchema;
+
+/** @internal */
+export const AnalysisConfigInputMultipleComparisonCorrectionScope$inboundSchema:
+  z.ZodNativeEnum<typeof AnalysisConfigInputMultipleComparisonCorrectionScope> =
+    z.nativeEnum(AnalysisConfigInputMultipleComparisonCorrectionScope);
+/** @internal */
+export const AnalysisConfigInputMultipleComparisonCorrectionScope$outboundSchema:
+  z.ZodNativeEnum<typeof AnalysisConfigInputMultipleComparisonCorrectionScope> =
+    AnalysisConfigInputMultipleComparisonCorrectionScope$inboundSchema;
+
+/** @internal */
+export const AnalysisConfigInput$inboundSchema: z.ZodType<
+  AnalysisConfigInput,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bayesianThreshold: z.string().optional(),
+  significanceThreshold: z.string().optional(),
+  testDirection: z.string().optional(),
+  multipleComparisonCorrectionMethod:
+    AnalysisConfigInputMultipleComparisonCorrectionMethod$inboundSchema
+      .optional(),
+  multipleComparisonCorrectionScope:
+    AnalysisConfigInputMultipleComparisonCorrectionScope$inboundSchema
+      .optional(),
+  sequentialTestingEnabled: z.boolean().optional(),
+});
+/** @internal */
+export type AnalysisConfigInput$Outbound = {
+  bayesianThreshold?: string | undefined;
+  significanceThreshold?: string | undefined;
+  testDirection?: string | undefined;
+  multipleComparisonCorrectionMethod?: string | undefined;
+  multipleComparisonCorrectionScope?: string | undefined;
+  sequentialTestingEnabled?: boolean | undefined;
+};
+
+/** @internal */
+export const AnalysisConfigInput$outboundSchema: z.ZodType<
+  AnalysisConfigInput$Outbound,
+  z.ZodTypeDef,
+  AnalysisConfigInput
+> = z.object({
+  bayesianThreshold: z.string().optional(),
+  significanceThreshold: z.string().optional(),
+  testDirection: z.string().optional(),
+  multipleComparisonCorrectionMethod:
+    AnalysisConfigInputMultipleComparisonCorrectionMethod$outboundSchema
+      .optional(),
+  multipleComparisonCorrectionScope:
+    AnalysisConfigInputMultipleComparisonCorrectionScope$outboundSchema
+      .optional(),
+  sequentialTestingEnabled: z.boolean().optional(),
+});
+
+export function analysisConfigInputToJSON(
+  analysisConfigInput: AnalysisConfigInput,
+): string {
+  return JSON.stringify(
+    AnalysisConfigInput$outboundSchema.parse(analysisConfigInput),
+  );
+}
+export function analysisConfigInputFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalysisConfigInput, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalysisConfigInput$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalysisConfigInput' from JSON`,
+  );
+}

package/src/models/components/analysisconfigrep.ts

@@ -0,0 +1,148 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import * as z from "zod/v3";
+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";
+
+/**
+ * The method for multiple comparison correction.
+ */
+export const AnalysisConfigRepMultipleComparisonCorrectionMethod = {
+  Bonferroni: "bonferroni",
+  BenjaminiHochberg: "benjamini-hochberg",
+} as const;
+/**
+ * The method for multiple comparison correction.
+ */
+export type AnalysisConfigRepMultipleComparisonCorrectionMethod = ClosedEnum<
+  typeof AnalysisConfigRepMultipleComparisonCorrectionMethod
+>;
+
+/**
+ * The scope for multiple comparison correction.
+ */
+export const AnalysisConfigRepMultipleComparisonCorrectionScope = {
+  Variations: "variations",
+  VariationsAndMetrics: "variations-and-metrics",
+  Metrics: "metrics",
+} as const;
+/**
+ * The scope for multiple comparison correction.
+ */
+export type AnalysisConfigRepMultipleComparisonCorrectionScope = ClosedEnum<
+  typeof AnalysisConfigRepMultipleComparisonCorrectionScope
+>;
+
+export type AnalysisConfigRep = {
+  /**
+   * The threshold for the Probability to Beat Baseline (PBBL) and Probability to Be Best (PBB) comparisons for the Bayesian results analysis approach.  Value should be between 0-100 inclusive.
+   */
+  bayesianThreshold?: string | null | undefined;
+  /**
+   * The significance threshold for the frequentist results analysis approach. Value should be between 0.0-1.0 inclusive.
+   */
+  significanceThreshold?: string | undefined;
+  /**
+   * The test sided direction for the frequentist results analysis approach.
+   */
+  testDirection?: string | undefined;
+  /**
+   * The method for multiple comparison correction.
+   */
+  multipleComparisonCorrectionMethod?:
+    | AnalysisConfigRepMultipleComparisonCorrectionMethod
+    | undefined;
+  /**
+   * The scope for multiple comparison correction.
+   */
+  multipleComparisonCorrectionScope?:
+    | AnalysisConfigRepMultipleComparisonCorrectionScope
+    | undefined;
+  /**
+   * Whether sequential testing is enabled for Frequentist analysis
+   */
+  sequentialTestingEnabled?: boolean | undefined;
+};
+
+/** @internal */
+export const AnalysisConfigRepMultipleComparisonCorrectionMethod$inboundSchema:
+  z.ZodNativeEnum<typeof AnalysisConfigRepMultipleComparisonCorrectionMethod> =
+    z.nativeEnum(AnalysisConfigRepMultipleComparisonCorrectionMethod);
+/** @internal */
+export const AnalysisConfigRepMultipleComparisonCorrectionMethod$outboundSchema:
+  z.ZodNativeEnum<typeof AnalysisConfigRepMultipleComparisonCorrectionMethod> =
+    AnalysisConfigRepMultipleComparisonCorrectionMethod$inboundSchema;
+
+/** @internal */
+export const AnalysisConfigRepMultipleComparisonCorrectionScope$inboundSchema:
+  z.ZodNativeEnum<typeof AnalysisConfigRepMultipleComparisonCorrectionScope> = z
+    .nativeEnum(AnalysisConfigRepMultipleComparisonCorrectionScope);
+/** @internal */
+export const AnalysisConfigRepMultipleComparisonCorrectionScope$outboundSchema:
+  z.ZodNativeEnum<typeof AnalysisConfigRepMultipleComparisonCorrectionScope> =
+    AnalysisConfigRepMultipleComparisonCorrectionScope$inboundSchema;
+
+/** @internal */
+export const AnalysisConfigRep$inboundSchema: z.ZodType<
+  AnalysisConfigRep,
+  z.ZodTypeDef,
+  unknown
+> = z.object({
+  bayesianThreshold: z.nullable(z.string()).optional(),
+  significanceThreshold: z.string().optional(),
+  testDirection: z.string().optional(),
+  multipleComparisonCorrectionMethod:
+    AnalysisConfigRepMultipleComparisonCorrectionMethod$inboundSchema
+      .optional(),
+  multipleComparisonCorrectionScope:
+    AnalysisConfigRepMultipleComparisonCorrectionScope$inboundSchema.optional(),
+  sequentialTestingEnabled: z.boolean().optional(),
+});
+/** @internal */
+export type AnalysisConfigRep$Outbound = {
+  bayesianThreshold?: string | null | undefined;
+  significanceThreshold?: string | undefined;
+  testDirection?: string | undefined;
+  multipleComparisonCorrectionMethod?: string | undefined;
+  multipleComparisonCorrectionScope?: string | undefined;
+  sequentialTestingEnabled?: boolean | undefined;
+};
+
+/** @internal */
+export const AnalysisConfigRep$outboundSchema: z.ZodType<
+  AnalysisConfigRep$Outbound,
+  z.ZodTypeDef,
+  AnalysisConfigRep
+> = z.object({
+  bayesianThreshold: z.nullable(z.string()).optional(),
+  significanceThreshold: z.string().optional(),
+  testDirection: z.string().optional(),
+  multipleComparisonCorrectionMethod:
+    AnalysisConfigRepMultipleComparisonCorrectionMethod$outboundSchema
+      .optional(),
+  multipleComparisonCorrectionScope:
+    AnalysisConfigRepMultipleComparisonCorrectionScope$outboundSchema
+      .optional(),
+  sequentialTestingEnabled: z.boolean().optional(),
+});
+
+export function analysisConfigRepToJSON(
+  analysisConfigRep: AnalysisConfigRep,
+): string {
+  return JSON.stringify(
+    AnalysisConfigRep$outboundSchema.parse(analysisConfigRep),
+  );
+}
+export function analysisConfigRepFromJSON(
+  jsonString: string,
+): SafeParseResult<AnalysisConfigRep, SDKValidationError> {
+  return safeParse(
+    jsonString,
+    (x) => AnalysisConfigRep$inboundSchema.parse(JSON.parse(x)),
+    `Failed to parse 'AnalysisConfigRep' from JSON`,
+  );
+}