// Code generated by oagen. DO NOT EDIT.

#[allow(unused_imports)]
use super::*;
#[allow(unused_imports)]
use crate::enums::*;
use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum AllItemsMatchConditionConditionOneOf {
    #[serde(rename = "exists")]
    ExistCondition(Box<ExistCondition>),
    #[serde(rename = "not_exists")]
    NotExistsCondition(Box<NotExistsCondition>),
    #[serde(rename = "equals")]
    EqualCondition(Box<EqualCondition>),
    #[serde(rename = "not_equals")]
    NotEqualsCondition(Box<NotEqualsCondition>),
    #[serde(rename = "number_compare")]
    NumberCompareCondition(Box<NumberCompareCondition>),
    #[serde(rename = "contains")]
    ContainCondition(Box<ContainCondition>),
    #[serde(rename = "object_contains")]
    ObjectContainsCondition(Box<ObjectContainsCondition>),
    #[serde(rename = "array_contains")]
    ArrayContainsCondition(Box<ArrayContainsCondition>),
    #[serde(rename = "matches_regex")]
    MatcheRegexCondition(Box<MatcheRegexCondition>),
    #[serde(rename = "json_schema_valid")]
    JsonSchemaValidCondition(Box<JsonSchemaValidCondition>),
    #[serde(rename = "similarity_gte")]
    SimilarityGteCondition(Box<SimilarityGteCondition>),
    #[serde(rename = "llm_judged_as")]
    LlmJudgedAsCondition(Box<LlmJudgedAsCondition>),
    #[serde(rename = "llm_not_judged_as")]
    LlmNotJudgedAsCondition(Box<LlmNotJudgedAsCondition>),
    #[serde(rename = "not_contains")]
    NotContainsCondition(Box<NotContainsCondition>),
    #[serde(rename = "length_compare")]
    LengthCompareCondition(Box<LengthCompareCondition>),
    #[serde(rename = "between")]
    BetweenCondition(Box<BetweenCondition>),
    #[serde(rename = "starts_with")]
    StartWithCondition(Box<StartWithCondition>),
    #[serde(rename = "ends_with")]
    EndsWithCondition(Box<EndsWithCondition>),
    #[serde(rename = "all_items_match")]
    AllItemsMatchCondition(Box<AllItemsMatchCondition>),
    #[serde(rename = "any_item_matches")]
    AnyItemMatchesCondition(Box<AnyItemMatchesCondition>),
    #[serde(rename = "split_iou_gte")]
    SplitIouCondition(Box<SplitIouCondition>),
}

impl From<ExistCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: ExistCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::ExistCondition(Box::new(v))
    }
}

impl From<NotExistsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: NotExistsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::NotExistsCondition(Box::new(v))
    }
}

impl From<EqualCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: EqualCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::EqualCondition(Box::new(v))
    }
}

impl From<NotEqualsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: NotEqualsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::NotEqualsCondition(Box::new(v))
    }
}

impl From<NumberCompareCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: NumberCompareCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::NumberCompareCondition(Box::new(v))
    }
}

impl From<ContainCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: ContainCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::ContainCondition(Box::new(v))
    }
}

impl From<ObjectContainsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: ObjectContainsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::ObjectContainsCondition(Box::new(v))
    }
}

impl From<ArrayContainsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: ArrayContainsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::ArrayContainsCondition(Box::new(v))
    }
}

impl From<MatcheRegexCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: MatcheRegexCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::MatcheRegexCondition(Box::new(v))
    }
}

impl From<JsonSchemaValidCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: JsonSchemaValidCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::JsonSchemaValidCondition(Box::new(v))
    }
}

impl From<SimilarityGteCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: SimilarityGteCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::SimilarityGteCondition(Box::new(v))
    }
}

impl From<LlmJudgedAsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: LlmJudgedAsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::LlmJudgedAsCondition(Box::new(v))
    }
}

impl From<LlmNotJudgedAsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: LlmNotJudgedAsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::LlmNotJudgedAsCondition(Box::new(v))
    }
}

impl From<NotContainsCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: NotContainsCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::NotContainsCondition(Box::new(v))
    }
}

impl From<LengthCompareCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: LengthCompareCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::LengthCompareCondition(Box::new(v))
    }
}

impl From<BetweenCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: BetweenCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::BetweenCondition(Box::new(v))
    }
}

impl From<StartWithCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: StartWithCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::StartWithCondition(Box::new(v))
    }
}

impl From<EndsWithCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: EndsWithCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::EndsWithCondition(Box::new(v))
    }
}

impl From<AllItemsMatchCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: AllItemsMatchCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::AllItemsMatchCondition(Box::new(v))
    }
}

impl From<AnyItemMatchesCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: AnyItemMatchesCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::AnyItemMatchesCondition(Box::new(v))
    }
}

impl From<SplitIouCondition> for AllItemsMatchConditionConditionOneOf {
    fn from(v: SplitIouCondition) -> Self {
        AllItemsMatchConditionConditionOneOf::SplitIouCondition(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BetweenConditionLowerOneOf {
    I64(i64),
    F64(f64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum StoredBlockExecutionLifecycleOneOf {
    #[serde(rename = "pending")]
    PendingBlockExecutionLifecycle(Box<PendingBlockExecutionLifecycle>),
    #[serde(rename = "queued")]
    QueuedBlockExecutionLifecycle(Box<QueuedBlockExecutionLifecycle>),
    #[serde(rename = "running")]
    RunningBlockExecutionLifecycle(Box<RunningBlockExecutionLifecycle>),
    #[serde(rename = "completed")]
    CompletedBlockExecutionLifecycle(Box<CompletedBlockExecutionLifecycle>),
    #[serde(rename = "error")]
    ErrorBlockExecutionLifecycle(Box<ErrorBlockExecutionLifecycle>),
    #[serde(rename = "cancelled")]
    CancelledBlockExecutionLifecycle(Box<CancelledBlockExecutionLifecycle>),
    #[serde(rename = "skipped")]
    SkippedBlockExecutionLifecycle(Box<SkippedBlockExecutionLifecycle>),
}

impl From<PendingBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: PendingBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::PendingBlockExecutionLifecycle(Box::new(v))
    }
}

impl From<QueuedBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: QueuedBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::QueuedBlockExecutionLifecycle(Box::new(v))
    }
}

impl From<RunningBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: RunningBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::RunningBlockExecutionLifecycle(Box::new(v))
    }
}

impl From<CompletedBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: CompletedBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::CompletedBlockExecutionLifecycle(Box::new(v))
    }
}

impl From<ErrorBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: ErrorBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::ErrorBlockExecutionLifecycle(Box::new(v))
    }
}

impl From<CancelledBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: CancelledBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::CancelledBlockExecutionLifecycle(Box::new(v))
    }
}

impl From<SkippedBlockExecutionLifecycle> for StoredBlockExecutionLifecycleOneOf {
    fn from(v: SkippedBlockExecutionLifecycle) -> Self {
        StoredBlockExecutionLifecycleOneOf::SkippedBlockExecutionLifecycle(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum StoredBlockExecutionHandleInputsOneOf {
    BlockExecJsonHandleInput(Box<BlockExecJsonHandleInput>),
    BlockExecFileHandleInput(Box<BlockExecFileHandleInput>),
}

impl From<BlockExecJsonHandleInput> for StoredBlockExecutionHandleInputsOneOf {
    fn from(v: BlockExecJsonHandleInput) -> Self {
        StoredBlockExecutionHandleInputsOneOf::BlockExecJsonHandleInput(Box::new(v))
    }
}

impl From<BlockExecFileHandleInput> for StoredBlockExecutionHandleInputsOneOf {
    fn from(v: BlockExecFileHandleInput) -> Self {
        StoredBlockExecutionHandleInputsOneOf::BlockExecFileHandleInput(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum CancelWorkflowExperimentRunResponseLifecycleOneOf {
    #[serde(rename = "pending")]
    PendingWorkflowExperimentRun(Box<PendingWorkflowExperimentRun>),
    #[serde(rename = "queued")]
    QueuedWorkflowExperimentRun(Box<QueuedWorkflowExperimentRun>),
    #[serde(rename = "running")]
    RunningWorkflowExperimentRun(Box<RunningWorkflowExperimentRun>),
    #[serde(rename = "completed")]
    CompletedWorkflowExperimentRun(Box<CompletedWorkflowExperimentRun>),
    #[serde(rename = "error")]
    ErrorWorkflowExperimentRun(Box<ErrorWorkflowExperimentRun>),
    #[serde(rename = "cancelled")]
    CancelledWorkflowExperimentRun(Box<CancelledWorkflowExperimentRun>),
}

impl From<PendingWorkflowExperimentRun> for CancelWorkflowExperimentRunResponseLifecycleOneOf {
    fn from(v: PendingWorkflowExperimentRun) -> Self {
        CancelWorkflowExperimentRunResponseLifecycleOneOf::PendingWorkflowExperimentRun(Box::new(v))
    }
}

impl From<QueuedWorkflowExperimentRun> for CancelWorkflowExperimentRunResponseLifecycleOneOf {
    fn from(v: QueuedWorkflowExperimentRun) -> Self {
        CancelWorkflowExperimentRunResponseLifecycleOneOf::QueuedWorkflowExperimentRun(Box::new(v))
    }
}

impl From<RunningWorkflowExperimentRun> for CancelWorkflowExperimentRunResponseLifecycleOneOf {
    fn from(v: RunningWorkflowExperimentRun) -> Self {
        CancelWorkflowExperimentRunResponseLifecycleOneOf::RunningWorkflowExperimentRun(Box::new(v))
    }
}

impl From<CompletedWorkflowExperimentRun> for CancelWorkflowExperimentRunResponseLifecycleOneOf {
    fn from(v: CompletedWorkflowExperimentRun) -> Self {
        CancelWorkflowExperimentRunResponseLifecycleOneOf::CompletedWorkflowExperimentRun(Box::new(
            v,
        ))
    }
}

impl From<ErrorWorkflowExperimentRun> for CancelWorkflowExperimentRunResponseLifecycleOneOf {
    fn from(v: ErrorWorkflowExperimentRun) -> Self {
        CancelWorkflowExperimentRunResponseLifecycleOneOf::ErrorWorkflowExperimentRun(Box::new(v))
    }
}

impl From<CancelledWorkflowExperimentRun> for CancelWorkflowExperimentRunResponseLifecycleOneOf {
    fn from(v: CancelledWorkflowExperimentRun) -> Self {
        CancelWorkflowExperimentRunResponseLifecycleOneOf::CancelledWorkflowExperimentRun(Box::new(
            v,
        ))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum CreateWorkflowEvalRequestSourceOneOf {
    #[serde(rename = "manual")]
    ManualWorkflowEvalSource(Box<ManualWorkflowEvalSource>),
    #[serde(rename = "run_step")]
    RunStepWorkflowEvalSource(Box<RunStepWorkflowEvalSource>),
}

impl From<ManualWorkflowEvalSource> for CreateWorkflowEvalRequestSourceOneOf {
    fn from(v: ManualWorkflowEvalSource) -> Self {
        CreateWorkflowEvalRequestSourceOneOf::ManualWorkflowEvalSource(Box::new(v))
    }
}

impl From<RunStepWorkflowEvalSource> for CreateWorkflowEvalRequestSourceOneOf {
    fn from(v: RunStepWorkflowEvalSource) -> Self {
        CreateWorkflowEvalRequestSourceOneOf::RunStepWorkflowEvalSource(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum CreateWorkflowEvalRunRequestScopeOneOf {
    #[serde(rename = "single")]
    WorkflowEvalRunSingleScope(Box<WorkflowEvalRunSingleScope>),
    #[serde(rename = "workflow")]
    WorkflowEvalRunWorkflowScope(Box<WorkflowEvalRunWorkflowScope>),
    #[serde(rename = "block")]
    WorkflowEvalRunBlockScope(Box<WorkflowEvalRunBlockScope>),
}

impl From<WorkflowEvalRunSingleScope> for CreateWorkflowEvalRunRequestScopeOneOf {
    fn from(v: WorkflowEvalRunSingleScope) -> Self {
        CreateWorkflowEvalRunRequestScopeOneOf::WorkflowEvalRunSingleScope(Box::new(v))
    }
}

impl From<WorkflowEvalRunWorkflowScope> for CreateWorkflowEvalRunRequestScopeOneOf {
    fn from(v: WorkflowEvalRunWorkflowScope) -> Self {
        CreateWorkflowEvalRunRequestScopeOneOf::WorkflowEvalRunWorkflowScope(Box::new(v))
    }
}

impl From<WorkflowEvalRunBlockScope> for CreateWorkflowEvalRunRequestScopeOneOf {
    fn from(v: WorkflowEvalRunBlockScope) -> Self {
        CreateWorkflowEvalRunRequestScopeOneOf::WorkflowEvalRunBlockScope(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeclarativePlanFieldChangePathOneOf {
    String(String),
    I64(i64),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ExperimentSummaryMetricsResponseAggregateOneOf {
    ExperimentExtractSummaryAggregate(Box<ExperimentExtractSummaryAggregate>),
    ExperimentConfusionSummaryAggregate(Box<ExperimentConfusionSummaryAggregate>),
}

impl From<ExperimentExtractSummaryAggregate> for ExperimentSummaryMetricsResponseAggregateOneOf {
    fn from(v: ExperimentExtractSummaryAggregate) -> Self {
        ExperimentSummaryMetricsResponseAggregateOneOf::ExperimentExtractSummaryAggregate(Box::new(
            v,
        ))
    }
}

impl From<ExperimentConfusionSummaryAggregate> for ExperimentSummaryMetricsResponseAggregateOneOf {
    fn from(v: ExperimentConfusionSummaryAggregate) -> Self {
        ExperimentSummaryMetricsResponseAggregateOneOf::ExperimentConfusionSummaryAggregate(
            Box::new(v),
        )
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ExplicitExperimentDocumentRequestHandleInputsOneOf {
    #[serde(rename = "json")]
    JsonHandleInput(Box<JsonHandleInput>),
    #[serde(rename = "file")]
    FileHandleInput(Box<FileHandleInput>),
}

impl From<JsonHandleInput> for ExplicitExperimentDocumentRequestHandleInputsOneOf {
    fn from(v: JsonHandleInput) -> Self {
        ExplicitExperimentDocumentRequestHandleInputsOneOf::JsonHandleInput(Box::new(v))
    }
}

impl From<FileHandleInput> for ExplicitExperimentDocumentRequestHandleInputsOneOf {
    fn from(v: FileHandleInput) -> Self {
        ExplicitExperimentDocumentRequestHandleInputsOneOf::FileHandleInput(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ManualWorkflowEvalSourceHandleInputsOneOf {
    #[serde(rename = "json")]
    EvalJsonHandleInput(Box<EvalJsonHandleInput>),
    #[serde(rename = "file")]
    EvalFileHandleInput(Box<EvalFileHandleInput>),
}

impl From<EvalJsonHandleInput> for ManualWorkflowEvalSourceHandleInputsOneOf {
    fn from(v: EvalJsonHandleInput) -> Self {
        ManualWorkflowEvalSourceHandleInputsOneOf::EvalJsonHandleInput(Box::new(v))
    }
}

impl From<EvalFileHandleInput> for ManualWorkflowEvalSourceHandleInputsOneOf {
    fn from(v: EvalFileHandleInput) -> Self {
        ManualWorkflowEvalSourceHandleInputsOneOf::EvalFileHandleInput(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum ReviewAllOfPredicatesOneOf {
    #[serde(rename = "always")]
    ReviewAlways(Box<ReviewAlways>),
    #[serde(rename = "validation_failed")]
    ReviewValidationFailed(Box<ReviewValidationFailed>),
    #[serde(rename = "confidence_lt")]
    ReviewConfidenceLt(Box<ReviewConfidenceLt>),
    #[serde(rename = "category_in")]
    ReviewCategoryIn(Box<ReviewCategoryIn>),
    #[serde(rename = "top_margin_lt")]
    ReviewTopMarginLt(Box<ReviewTopMarginLt>),
    #[serde(rename = "split_count_neq")]
    ReviewSplitCountNeq(Box<ReviewSplitCountNeq>),
    #[serde(rename = "any_split_pages_lt")]
    ReviewAnySplitPagesLt(Box<ReviewAnySplitPagesLt>),
    #[serde(rename = "boundary_confidence_lt")]
    ReviewBoundaryConfidenceLt(Box<ReviewBoundaryConfidenceLt>),
    #[serde(rename = "any_required_field_null")]
    ReviewAnyRequiredFieldNull(Box<ReviewAnyRequiredFieldNull>),
    #[serde(rename = "field_confidence_lt")]
    ReviewFieldConfidenceLt(Box<ReviewFieldConfidenceLt>),
    #[serde(rename = "json_condition")]
    ReviewJsonCondition(Box<ReviewJsonCondition>),
    #[serde(rename = "branch_in")]
    ReviewBranchIn(Box<ReviewBranchIn>),
    #[serde(rename = "any_of")]
    ReviewAnyOf(Box<ReviewAnyOf>),
    #[serde(rename = "all_of")]
    ReviewAllOf(Box<ReviewAllOf>),
}

impl From<ReviewAlways> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewAlways) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewAlways(Box::new(v))
    }
}

impl From<ReviewValidationFailed> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewValidationFailed) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewValidationFailed(Box::new(v))
    }
}

impl From<ReviewConfidenceLt> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewConfidenceLt) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewConfidenceLt(Box::new(v))
    }
}

impl From<ReviewCategoryIn> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewCategoryIn) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewCategoryIn(Box::new(v))
    }
}

impl From<ReviewTopMarginLt> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewTopMarginLt) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewTopMarginLt(Box::new(v))
    }
}

impl From<ReviewSplitCountNeq> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewSplitCountNeq) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewSplitCountNeq(Box::new(v))
    }
}

impl From<ReviewAnySplitPagesLt> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewAnySplitPagesLt) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewAnySplitPagesLt(Box::new(v))
    }
}

impl From<ReviewBoundaryConfidenceLt> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewBoundaryConfidenceLt) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewBoundaryConfidenceLt(Box::new(v))
    }
}

impl From<ReviewAnyRequiredFieldNull> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewAnyRequiredFieldNull) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewAnyRequiredFieldNull(Box::new(v))
    }
}

impl From<ReviewFieldConfidenceLt> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewFieldConfidenceLt) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewFieldConfidenceLt(Box::new(v))
    }
}

impl From<ReviewJsonCondition> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewJsonCondition) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewJsonCondition(Box::new(v))
    }
}

impl From<ReviewBranchIn> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewBranchIn) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewBranchIn(Box::new(v))
    }
}

impl From<ReviewAnyOf> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewAnyOf) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewAnyOf(Box::new(v))
    }
}

impl From<ReviewAllOf> for ReviewAllOfPredicatesOneOf {
    fn from(v: ReviewAllOf) -> Self {
        ReviewAllOfPredicatesOneOf::ReviewAllOf(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum WorkflowEvalResultLifecycleOneOf {
    #[serde(rename = "pending")]
    PendingWorkflowEvalRun(Box<PendingWorkflowEvalRun>),
    #[serde(rename = "queued")]
    QueuedWorkflowEvalRun(Box<QueuedWorkflowEvalRun>),
    #[serde(rename = "running")]
    RunningWorkflowEvalRun(Box<RunningWorkflowEvalRun>),
    #[serde(rename = "completed")]
    CompletedWorkflowEvalRun(Box<CompletedWorkflowEvalRun>),
    #[serde(rename = "error")]
    ErrorWorkflowEvalRun(Box<ErrorWorkflowEvalRun>),
    #[serde(rename = "cancelled")]
    CancelledWorkflowEvalRun(Box<CancelledWorkflowEvalRun>),
}

impl From<PendingWorkflowEvalRun> for WorkflowEvalResultLifecycleOneOf {
    fn from(v: PendingWorkflowEvalRun) -> Self {
        WorkflowEvalResultLifecycleOneOf::PendingWorkflowEvalRun(Box::new(v))
    }
}

impl From<QueuedWorkflowEvalRun> for WorkflowEvalResultLifecycleOneOf {
    fn from(v: QueuedWorkflowEvalRun) -> Self {
        WorkflowEvalResultLifecycleOneOf::QueuedWorkflowEvalRun(Box::new(v))
    }
}

impl From<RunningWorkflowEvalRun> for WorkflowEvalResultLifecycleOneOf {
    fn from(v: RunningWorkflowEvalRun) -> Self {
        WorkflowEvalResultLifecycleOneOf::RunningWorkflowEvalRun(Box::new(v))
    }
}

impl From<CompletedWorkflowEvalRun> for WorkflowEvalResultLifecycleOneOf {
    fn from(v: CompletedWorkflowEvalRun) -> Self {
        WorkflowEvalResultLifecycleOneOf::CompletedWorkflowEvalRun(Box::new(v))
    }
}

impl From<ErrorWorkflowEvalRun> for WorkflowEvalResultLifecycleOneOf {
    fn from(v: ErrorWorkflowEvalRun) -> Self {
        WorkflowEvalResultLifecycleOneOf::ErrorWorkflowEvalRun(Box::new(v))
    }
}

impl From<CancelledWorkflowEvalRun> for WorkflowEvalResultLifecycleOneOf {
    fn from(v: CancelledWorkflowEvalRun) -> Self {
        WorkflowEvalResultLifecycleOneOf::CancelledWorkflowEvalRun(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum ExperimentResultLifecycleOneOf {
    #[serde(rename = "pending")]
    PendingWorkflowExperimentResult(Box<PendingWorkflowExperimentResult>),
    #[serde(rename = "queued")]
    QueuedWorkflowExperimentResult(Box<QueuedWorkflowExperimentResult>),
    #[serde(rename = "running")]
    RunningWorkflowExperimentResult(Box<RunningWorkflowExperimentResult>),
    #[serde(rename = "completed")]
    CompletedWorkflowExperimentResult(Box<CompletedWorkflowExperimentResult>),
    #[serde(rename = "error")]
    ErrorWorkflowExperimentResult(Box<ErrorWorkflowExperimentResult>),
    #[serde(rename = "cancelled")]
    CancelledWorkflowExperimentResult(Box<CancelledWorkflowExperimentResult>),
}

impl From<PendingWorkflowExperimentResult> for ExperimentResultLifecycleOneOf {
    fn from(v: PendingWorkflowExperimentResult) -> Self {
        ExperimentResultLifecycleOneOf::PendingWorkflowExperimentResult(Box::new(v))
    }
}

impl From<QueuedWorkflowExperimentResult> for ExperimentResultLifecycleOneOf {
    fn from(v: QueuedWorkflowExperimentResult) -> Self {
        ExperimentResultLifecycleOneOf::QueuedWorkflowExperimentResult(Box::new(v))
    }
}

impl From<RunningWorkflowExperimentResult> for ExperimentResultLifecycleOneOf {
    fn from(v: RunningWorkflowExperimentResult) -> Self {
        ExperimentResultLifecycleOneOf::RunningWorkflowExperimentResult(Box::new(v))
    }
}

impl From<CompletedWorkflowExperimentResult> for ExperimentResultLifecycleOneOf {
    fn from(v: CompletedWorkflowExperimentResult) -> Self {
        ExperimentResultLifecycleOneOf::CompletedWorkflowExperimentResult(Box::new(v))
    }
}

impl From<ErrorWorkflowExperimentResult> for ExperimentResultLifecycleOneOf {
    fn from(v: ErrorWorkflowExperimentResult) -> Self {
        ExperimentResultLifecycleOneOf::ErrorWorkflowExperimentResult(Box::new(v))
    }
}

impl From<CancelledWorkflowExperimentResult> for ExperimentResultLifecycleOneOf {
    fn from(v: CancelledWorkflowExperimentResult) -> Self {
        ExperimentResultLifecycleOneOf::CancelledWorkflowExperimentResult(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum WorkflowRunLifecycleOneOf {
    #[serde(rename = "pending")]
    PendingRun(Box<PendingRun>),
    #[serde(rename = "running")]
    RunningRun(Box<RunningRun>),
    #[serde(rename = "awaiting_review")]
    AwaitingReviewRun(Box<AwaitingReviewRun>),
    #[serde(rename = "completed")]
    CompletedTerminal(Box<CompletedTerminal>),
    #[serde(rename = "error")]
    ErrorTerminal(Box<ErrorTerminal>),
    #[serde(rename = "cancelled")]
    CancelledTerminal(Box<CancelledTerminal>),
}

impl From<PendingRun> for WorkflowRunLifecycleOneOf {
    fn from(v: PendingRun) -> Self {
        WorkflowRunLifecycleOneOf::PendingRun(Box::new(v))
    }
}

impl From<RunningRun> for WorkflowRunLifecycleOneOf {
    fn from(v: RunningRun) -> Self {
        WorkflowRunLifecycleOneOf::RunningRun(Box::new(v))
    }
}

impl From<AwaitingReviewRun> for WorkflowRunLifecycleOneOf {
    fn from(v: AwaitingReviewRun) -> Self {
        WorkflowRunLifecycleOneOf::AwaitingReviewRun(Box::new(v))
    }
}

impl From<CompletedTerminal> for WorkflowRunLifecycleOneOf {
    fn from(v: CompletedTerminal) -> Self {
        WorkflowRunLifecycleOneOf::CompletedTerminal(Box::new(v))
    }
}

impl From<ErrorTerminal> for WorkflowRunLifecycleOneOf {
    fn from(v: ErrorTerminal) -> Self {
        WorkflowRunLifecycleOneOf::ErrorTerminal(Box::new(v))
    }
}

impl From<CancelledTerminal> for WorkflowRunLifecycleOneOf {
    fn from(v: CancelledTerminal) -> Self {
        WorkflowRunLifecycleOneOf::CancelledTerminal(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "status")]
pub enum WorkflowRunStepLifecycleOneOf {
    #[serde(rename = "pending")]
    PendingStepLifecycle(Box<PendingStepLifecycle>),
    #[serde(rename = "queued")]
    QueuedStepLifecycle(Box<QueuedStepLifecycle>),
    #[serde(rename = "running")]
    RunningStepLifecycle(Box<RunningStepLifecycle>),
    #[serde(rename = "completed")]
    CompletedStepLifecycle(Box<CompletedStepLifecycle>),
    #[serde(rename = "awaiting_review")]
    AwaitingReviewStepLifecycle(Box<AwaitingReviewStepLifecycle>),
    #[serde(rename = "error")]
    ErrorStepLifecycle(Box<ErrorStepLifecycle>),
    #[serde(rename = "skipped")]
    SkippedStepLifecycle(Box<SkippedStepLifecycle>),
    #[serde(rename = "cancelled")]
    CancelledStepLifecycle(Box<CancelledStepLifecycle>),
}

impl From<PendingStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: PendingStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::PendingStepLifecycle(Box::new(v))
    }
}

impl From<QueuedStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: QueuedStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::QueuedStepLifecycle(Box::new(v))
    }
}

impl From<RunningStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: RunningStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::RunningStepLifecycle(Box::new(v))
    }
}

impl From<CompletedStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: CompletedStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::CompletedStepLifecycle(Box::new(v))
    }
}

impl From<AwaitingReviewStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: AwaitingReviewStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::AwaitingReviewStepLifecycle(Box::new(v))
    }
}

impl From<ErrorStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: ErrorStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::ErrorStepLifecycle(Box::new(v))
    }
}

impl From<SkippedStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: SkippedStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::SkippedStepLifecycle(Box::new(v))
    }
}

impl From<CancelledStepLifecycle> for WorkflowRunStepLifecycleOneOf {
    fn from(v: CancelledStepLifecycle) -> Self {
        WorkflowRunStepLifecycleOneOf::CancelledStepLifecycle(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "operation")]
pub enum GetWorkflowArtifactByIdResponseOneOf {
    #[serde(rename = "extraction")]
    ExtractionWorkflowArtifact(Box<ExtractionWorkflowArtifact>),
    #[serde(rename = "split")]
    SplitWorkflowArtifact(Box<SplitWorkflowArtifact>),
    #[serde(rename = "classification")]
    ClassificationWorkflowArtifact(Box<ClassificationWorkflowArtifact>),
    #[serde(rename = "parse")]
    ParseWorkflowArtifact(Box<ParseWorkflowArtifact>),
    #[serde(rename = "edit")]
    EditWorkflowArtifact(Box<EditWorkflowArtifact>),
    #[serde(rename = "partition")]
    PartitionWorkflowArtifact(Box<PartitionWorkflowArtifact>),
    #[serde(rename = "conditional_evaluation")]
    ConditionalEvaluation(Box<ConditionalEvaluation>),
    #[serde(rename = "review_trigger_evaluation")]
    ReviewEvaluation(Box<ReviewEvaluation>),
    #[serde(rename = "while_loop_termination")]
    WhileLoopTermination(Box<WhileLoopTermination>),
    #[serde(rename = "api_call_invocation")]
    ApiCallInvocation(Box<ApiCallInvocation>),
    #[serde(rename = "function_invocation")]
    FunctionInvocation(Box<FunctionInvocation>),
}

impl From<ExtractionWorkflowArtifact> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: ExtractionWorkflowArtifact) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::ExtractionWorkflowArtifact(Box::new(v))
    }
}

impl From<SplitWorkflowArtifact> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: SplitWorkflowArtifact) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::SplitWorkflowArtifact(Box::new(v))
    }
}

impl From<ClassificationWorkflowArtifact> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: ClassificationWorkflowArtifact) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::ClassificationWorkflowArtifact(Box::new(v))
    }
}

impl From<ParseWorkflowArtifact> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: ParseWorkflowArtifact) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::ParseWorkflowArtifact(Box::new(v))
    }
}

impl From<EditWorkflowArtifact> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: EditWorkflowArtifact) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::EditWorkflowArtifact(Box::new(v))
    }
}

impl From<PartitionWorkflowArtifact> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: PartitionWorkflowArtifact) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::PartitionWorkflowArtifact(Box::new(v))
    }
}

impl From<ConditionalEvaluation> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: ConditionalEvaluation) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::ConditionalEvaluation(Box::new(v))
    }
}

impl From<ReviewEvaluation> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: ReviewEvaluation) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::ReviewEvaluation(Box::new(v))
    }
}

impl From<WhileLoopTermination> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: WhileLoopTermination) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::WhileLoopTermination(Box::new(v))
    }
}

impl From<ApiCallInvocation> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: ApiCallInvocation) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::ApiCallInvocation(Box::new(v))
    }
}

impl From<FunctionInvocation> for GetWorkflowArtifactByIdResponseOneOf {
    fn from(v: FunctionInvocation) -> Self {
        GetWorkflowArtifactByIdResponseOneOf::FunctionInvocation(Box::new(v))
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "kind")]
pub enum GetExperimentMetricsForRunResponseOneOf {
    #[serde(rename = "summary")]
    ExperimentSummaryMetricsResponse(Box<ExperimentSummaryMetricsResponse>),
    #[serde(rename = "by_document")]
    ExperimentByDocumentMetricsResponse(Box<ExperimentByDocumentMetricsResponse>),
    #[serde(rename = "by_target")]
    ExperimentByTargetMetricsResponse(Box<ExperimentByTargetMetricsResponse>),
    #[serde(rename = "votes")]
    ExperimentVotesMetricsResponse(Box<ExperimentVotesMetricsResponse>),
    #[serde(rename = "stale_metrics")]
    ExperimentMetricsStaleError(Box<ExperimentMetricsStaleError>),
    #[serde(rename = "no_metrics")]
    ExperimentMetricsMissingError(Box<ExperimentMetricsMissingError>),
}

impl From<ExperimentSummaryMetricsResponse> for GetExperimentMetricsForRunResponseOneOf {
    fn from(v: ExperimentSummaryMetricsResponse) -> Self {
        GetExperimentMetricsForRunResponseOneOf::ExperimentSummaryMetricsResponse(Box::new(v))
    }
}

impl From<ExperimentByDocumentMetricsResponse> for GetExperimentMetricsForRunResponseOneOf {
    fn from(v: ExperimentByDocumentMetricsResponse) -> Self {
        GetExperimentMetricsForRunResponseOneOf::ExperimentByDocumentMetricsResponse(Box::new(v))
    }
}

impl From<ExperimentByTargetMetricsResponse> for GetExperimentMetricsForRunResponseOneOf {
    fn from(v: ExperimentByTargetMetricsResponse) -> Self {
        GetExperimentMetricsForRunResponseOneOf::ExperimentByTargetMetricsResponse(Box::new(v))
    }
}

impl From<ExperimentVotesMetricsResponse> for GetExperimentMetricsForRunResponseOneOf {
    fn from(v: ExperimentVotesMetricsResponse) -> Self {
        GetExperimentMetricsForRunResponseOneOf::ExperimentVotesMetricsResponse(Box::new(v))
    }
}

impl From<ExperimentMetricsStaleError> for GetExperimentMetricsForRunResponseOneOf {
    fn from(v: ExperimentMetricsStaleError) -> Self {
        GetExperimentMetricsForRunResponseOneOf::ExperimentMetricsStaleError(Box::new(v))
    }
}

impl From<ExperimentMetricsMissingError> for GetExperimentMetricsForRunResponseOneOf {
    fn from(v: ExperimentMetricsMissingError) -> Self {
        GetExperimentMetricsForRunResponseOneOf::ExperimentMetricsMissingError(Box::new(v))
    }
}
