mizchi/flaker/contracts

README
U
AffectedDirectSelectionInput
U
AffectedReportCoreOutput
U
AffectedReportInput
U
AffectedReportSummaryOutput
U
AffectedSelectionOutput
U
AffectedTargetInput
U
AffectedTransitiveTaskInput
U
ConfigCheckCoreOutput
U
ConfigCheckIssueOutput
U
ConfigCheckListedTestInput
U
ConfigCheckSummaryOutput
U
ConfigCheckTaskDefinitionInput
U
ConfigOwnershipClaimOutput
U
ConfigOwnershipEntryOutput
U
ConfigTaskSummaryOutput
U
DependencyGraphInput
U
DetectInput
U
DetectOutput
U
EvalCommitSignalInput
U
FlakyResult
U
GraphNodeInput
U
HoldoutCommitInput
U
HoldoutKpiOutput
U
QuarantineEntryInput
U
QuarantineIssueOutput
U
QuarantineModeCountsOutput
U
QuarantineRuntimeResultInput
U
QuarantineScopeCountsOutput
U
QuarantineSummaryCoreOutput
U
QuarantineTaskOwnershipInput
U
ReportAggregateOutput
U
ReportAggregateShardInput
U
ReportAggregateUnstableBuckets
U
ReportAggregateUnstableStatusInput
U
ReportDiffBuckets
U
ReportDiffStatusInput
U
ReportFileTotalsOutput
U
ReportSummaryOutput
U
ReportSummaryTestInput
U
ReportTotalsInput
U
ResolvedQuarantineEntryOutput
U
ResolvedStableTestIdentityOutput
U
ReverseDepEntry
U
SamplingHistoryRowInput
U
SamplingKpiConfusionMatrixOutput
U
SamplingKpiMissesOutput
U
SamplingKpiOutput
U
SamplingKpiSignalOutput
U
SamplingListedTestInput
U
StableTestIdentityInput
U
StableVariantEntryInput
U
TestMeta
U
TestRunEntry
V
aggregate_report
V
build_affected_report
V
build_affected_report_from_input
V
build_holdout_kpi
V
build_reverse_deps
V
build_sampling_kpi
V
build_sampling_meta
V
classify_report_diff
V
compute_quarantine_exit_code
V
create_stable_test_id
V
dedupe_affected_targets
V
detect_flaky
V
expand_transitive
V
find_affected_nodes
V
find_matching_quarantine
V
get_affected_test_patterns
V
is_blocking_failure
V
resolve_affected
V
resolve_test_identity
V
run_config_check
V
sample_hybrid
V
sample_random
V
sample_weighted
V
summarize_quarantine
V
summarize_report
V
topological_sort

mizchi/flaker/contracts does not have a README file

AffectedDirectSelectionInput

pub(all) struct AffectedDirectSelectionInput {
  spec : String
  task_id : String
  filter : String?
  matched_paths : Array[String]
  match_reasons : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedDirectSelectionInput::equal

source

fn AffectedDirectSelectionInput::equal(AffectedDirectSelectionInput, AffectedDirectSelectionInput) -> Bool

AffectedDirectSelectionInput::from_json

source

fn AffectedDirectSelectionInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedDirectSelectionInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedDirectSelectionInput::not_equal

source

fn AffectedDirectSelectionInput::not_equal(x : AffectedDirectSelectionInput, y : AffectedDirectSelectionInput) -> Bool

AffectedDirectSelectionInput::output

source

fn AffectedDirectSelectionInput::output(AffectedDirectSelectionInput, &Logger) -> Unit

AffectedDirectSelectionInput::to_json

source

fn AffectedDirectSelectionInput::to_json(AffectedDirectSelectionInput) -> @moonbitlang/core/json.Json
Json

AffectedDirectSelectionInput::to_repr

source

fn AffectedDirectSelectionInput::to_repr(AffectedDirectSelectionInput) -> @moonbitlang/core/debug.Repr
Repr

AffectedDirectSelectionInput::to_string

source

fn AffectedDirectSelectionInput::to_string(self : AffectedDirectSelectionInput) -> String

AffectedReportCoreOutput

source

pub(all) struct AffectedReportCoreOutput {
  matched : Array[AffectedSelectionOutput]
  selected : Array[AffectedSelectionOutput]
  unmatched : Array[String]
  summary : AffectedReportSummaryOutput
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedReportCoreOutput::equal

source

fn AffectedReportCoreOutput::equal(AffectedReportCoreOutput, AffectedReportCoreOutput) -> Bool

AffectedReportCoreOutput::from_json

source

fn AffectedReportCoreOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedReportCoreOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedReportCoreOutput::not_equal

source

fn AffectedReportCoreOutput::not_equal(x : AffectedReportCoreOutput, y : AffectedReportCoreOutput) -> Bool

AffectedReportCoreOutput::output

source

fn AffectedReportCoreOutput::output(AffectedReportCoreOutput, &Logger) -> Unit

AffectedReportCoreOutput::to_json

source

fn AffectedReportCoreOutput::to_json(AffectedReportCoreOutput) -> @moonbitlang/core/json.Json
Json

AffectedReportCoreOutput::to_repr

source

fn AffectedReportCoreOutput::to_repr(AffectedReportCoreOutput) -> @moonbitlang/core/debug.Repr
Repr

AffectedReportCoreOutput::to_string

source

fn AffectedReportCoreOutput::to_string(self : AffectedReportCoreOutput) -> String

AffectedReportInput

source

pub(all) struct AffectedReportInput {
  targets : Array[AffectedTargetInput]
  direct_selections : Array[AffectedDirectSelectionInput]
  transitive_tasks : Array[AffectedTransitiveTaskInput]
  unmatched : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedReportInput::equal

source

fn AffectedReportInput::equal(AffectedReportInput, AffectedReportInput) -> Bool

AffectedReportInput::from_json

source

fn AffectedReportInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedReportInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedReportInput::not_equal

source

fn AffectedReportInput::not_equal(x : AffectedReportInput, y : AffectedReportInput) -> Bool

AffectedReportInput::output

source

fn AffectedReportInput::output(AffectedReportInput, &Logger) -> Unit

AffectedReportInput::to_json

source

fn AffectedReportInput::to_json(AffectedReportInput) -> @moonbitlang/core/json.Json
Json

AffectedReportInput::to_repr

source

fn AffectedReportInput::to_repr(AffectedReportInput) -> @moonbitlang/core/debug.Repr
Repr

AffectedReportInput::to_string

source

fn AffectedReportInput::to_string(self : AffectedReportInput) -> String

AffectedReportSummaryOutput

source

pub(all) struct AffectedReportSummaryOutput {
  matched_count : Int
  selected_count : Int
  unmatched_count : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedReportSummaryOutput::equal

source

fn AffectedReportSummaryOutput::equal(AffectedReportSummaryOutput, AffectedReportSummaryOutput) -> Bool

AffectedReportSummaryOutput::from_json

source

fn AffectedReportSummaryOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedReportSummaryOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedReportSummaryOutput::not_equal

source

fn AffectedReportSummaryOutput::not_equal(x : AffectedReportSummaryOutput, y : AffectedReportSummaryOutput) -> Bool

AffectedReportSummaryOutput::output

source

fn AffectedReportSummaryOutput::output(AffectedReportSummaryOutput, &Logger) -> Unit

AffectedReportSummaryOutput::to_json

source

fn AffectedReportSummaryOutput::to_json(AffectedReportSummaryOutput) -> @moonbitlang/core/json.Json
Json

AffectedReportSummaryOutput::to_repr

source

fn AffectedReportSummaryOutput::to_repr(AffectedReportSummaryOutput) -> @moonbitlang/core/debug.Repr
Repr

AffectedReportSummaryOutput::to_string

source

fn AffectedReportSummaryOutput::to_string(self : AffectedReportSummaryOutput) -> String

AffectedSelectionOutput

source

pub(all) struct AffectedSelectionOutput {
  task_id : String
  spec : String
  filter : String?
  direct : Bool
  included_by : Array[String]
  matched_paths : Array[String]
  match_reasons : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedSelectionOutput::equal

source

fn AffectedSelectionOutput::equal(AffectedSelectionOutput, AffectedSelectionOutput) -> Bool

AffectedSelectionOutput::from_json

source

fn AffectedSelectionOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedSelectionOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedSelectionOutput::not_equal

source

fn AffectedSelectionOutput::not_equal(x : AffectedSelectionOutput, y : AffectedSelectionOutput) -> Bool

AffectedSelectionOutput::output

source

fn AffectedSelectionOutput::output(AffectedSelectionOutput, &Logger) -> Unit

AffectedSelectionOutput::to_json

source

fn AffectedSelectionOutput::to_json(AffectedSelectionOutput) -> @moonbitlang/core/json.Json
Json

AffectedSelectionOutput::to_repr

source

fn AffectedSelectionOutput::to_repr(AffectedSelectionOutput) -> @moonbitlang/core/debug.Repr
Repr

AffectedSelectionOutput::to_string

source

fn AffectedSelectionOutput::to_string(self : AffectedSelectionOutput) -> String

AffectedTargetInput

source

pub(all) struct AffectedTargetInput {
  spec : String
  task_id : String
  filter : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedTargetInput::equal

source

fn AffectedTargetInput::equal(AffectedTargetInput, AffectedTargetInput) -> Bool

AffectedTargetInput::from_json

source

fn AffectedTargetInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedTargetInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedTargetInput::not_equal

source

fn AffectedTargetInput::not_equal(x : AffectedTargetInput, y : AffectedTargetInput) -> Bool

AffectedTargetInput::output

source

fn AffectedTargetInput::output(AffectedTargetInput, &Logger) -> Unit

AffectedTargetInput::to_json

source

fn AffectedTargetInput::to_json(AffectedTargetInput) -> @moonbitlang/core/json.Json
Json

AffectedTargetInput::to_repr

source

fn AffectedTargetInput::to_repr(AffectedTargetInput) -> @moonbitlang/core/debug.Repr
Repr

AffectedTargetInput::to_string

source

fn AffectedTargetInput::to_string(self : AffectedTargetInput) -> String

AffectedTransitiveTaskInput

source

pub(all) struct AffectedTransitiveTaskInput {
  task_id : String
  included_by : Array[String]
  match_reasons : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

AffectedTransitiveTaskInput::equal

source

fn AffectedTransitiveTaskInput::equal(AffectedTransitiveTaskInput, AffectedTransitiveTaskInput) -> Bool

AffectedTransitiveTaskInput::from_json

source

fn AffectedTransitiveTaskInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> AffectedTransitiveTaskInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

AffectedTransitiveTaskInput::not_equal

source

fn AffectedTransitiveTaskInput::not_equal(x : AffectedTransitiveTaskInput, y : AffectedTransitiveTaskInput) -> Bool

AffectedTransitiveTaskInput::output

source

fn AffectedTransitiveTaskInput::output(AffectedTransitiveTaskInput, &Logger) -> Unit

AffectedTransitiveTaskInput::to_json

source

fn AffectedTransitiveTaskInput::to_json(AffectedTransitiveTaskInput) -> @moonbitlang/core/json.Json
Json

AffectedTransitiveTaskInput::to_repr

source

fn AffectedTransitiveTaskInput::to_repr(AffectedTransitiveTaskInput) -> @moonbitlang/core/debug.Repr
Repr

AffectedTransitiveTaskInput::to_string

source

fn AffectedTransitiveTaskInput::to_string(self : AffectedTransitiveTaskInput) -> String

ConfigCheckCoreOutput

source

pub(all) struct ConfigCheckCoreOutput {
  summary : ConfigCheckSummaryOutput
  ownership : Array[ConfigOwnershipEntryOutput]
  tasks : Array[ConfigTaskSummaryOutput]
  errors : Array[ConfigCheckIssueOutput]
  warnings : Array[ConfigCheckIssueOutput]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigCheckCoreOutput::equal

source

fn ConfigCheckCoreOutput::equal(ConfigCheckCoreOutput, ConfigCheckCoreOutput) -> Bool

ConfigCheckCoreOutput::from_json

source

fn ConfigCheckCoreOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigCheckCoreOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigCheckCoreOutput::not_equal

source

fn ConfigCheckCoreOutput::not_equal(x : ConfigCheckCoreOutput, y : ConfigCheckCoreOutput) -> Bool

ConfigCheckCoreOutput::output

source

fn ConfigCheckCoreOutput::output(ConfigCheckCoreOutput, &Logger) -> Unit

ConfigCheckCoreOutput::to_json

source

fn ConfigCheckCoreOutput::to_json(ConfigCheckCoreOutput) -> @moonbitlang/core/json.Json
Json

ConfigCheckCoreOutput::to_repr

source

fn ConfigCheckCoreOutput::to_repr(ConfigCheckCoreOutput) -> @moonbitlang/core/debug.Repr
Repr

ConfigCheckCoreOutput::to_string

source

fn ConfigCheckCoreOutput::to_string(self : ConfigCheckCoreOutput) -> String

ConfigCheckIssueOutput

source

pub(all) struct ConfigCheckIssueOutput {
  code : String
  spec : String
  detail : String
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigCheckIssueOutput::equal

source

fn ConfigCheckIssueOutput::equal(ConfigCheckIssueOutput, ConfigCheckIssueOutput) -> Bool

ConfigCheckIssueOutput::from_json

source

fn ConfigCheckIssueOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigCheckIssueOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigCheckIssueOutput::not_equal

source

fn ConfigCheckIssueOutput::not_equal(x : ConfigCheckIssueOutput, y : ConfigCheckIssueOutput) -> Bool

ConfigCheckIssueOutput::output

source

fn ConfigCheckIssueOutput::output(ConfigCheckIssueOutput, &Logger) -> Unit

ConfigCheckIssueOutput::to_json

source

fn ConfigCheckIssueOutput::to_json(ConfigCheckIssueOutput) -> @moonbitlang/core/json.Json
Json

ConfigCheckIssueOutput::to_repr

source

fn ConfigCheckIssueOutput::to_repr(ConfigCheckIssueOutput) -> @moonbitlang/core/debug.Repr
Repr

ConfigCheckIssueOutput::to_string

source

fn ConfigCheckIssueOutput::to_string(self : ConfigCheckIssueOutput) -> String

ConfigCheckListedTestInput

source

pub(all) struct ConfigCheckListedTestInput {
  suite : String
  task_id : String
  filter : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigCheckListedTestInput::equal

source

fn ConfigCheckListedTestInput::equal(ConfigCheckListedTestInput, ConfigCheckListedTestInput) -> Bool

ConfigCheckListedTestInput::from_json

source

fn ConfigCheckListedTestInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigCheckListedTestInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigCheckListedTestInput::not_equal

source

fn ConfigCheckListedTestInput::not_equal(x : ConfigCheckListedTestInput, y : ConfigCheckListedTestInput) -> Bool

ConfigCheckListedTestInput::output

source

fn ConfigCheckListedTestInput::output(ConfigCheckListedTestInput, &Logger) -> Unit

ConfigCheckListedTestInput::to_json

source

fn ConfigCheckListedTestInput::to_json(ConfigCheckListedTestInput) -> @moonbitlang/core/json.Json
Json

ConfigCheckListedTestInput::to_repr

source

fn ConfigCheckListedTestInput::to_repr(ConfigCheckListedTestInput) -> @moonbitlang/core/debug.Repr
Repr

ConfigCheckListedTestInput::to_string

source

fn ConfigCheckListedTestInput::to_string(self : ConfigCheckListedTestInput) -> String

ConfigCheckSummaryOutput

source

pub(all) struct ConfigCheckSummaryOutput {
  task_count : Int
  spec_count : Int
  duplicate_ownership_count : Int
  split_ownership_count : Int
  unmanaged_spec_count : Int
  error_count : Int
  warning_count : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigCheckSummaryOutput::equal

source

fn ConfigCheckSummaryOutput::equal(ConfigCheckSummaryOutput, ConfigCheckSummaryOutput) -> Bool

ConfigCheckSummaryOutput::from_json

source

fn ConfigCheckSummaryOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigCheckSummaryOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigCheckSummaryOutput::not_equal

source

fn ConfigCheckSummaryOutput::not_equal(x : ConfigCheckSummaryOutput, y : ConfigCheckSummaryOutput) -> Bool

ConfigCheckSummaryOutput::output

source

fn ConfigCheckSummaryOutput::output(ConfigCheckSummaryOutput, &Logger) -> Unit

ConfigCheckSummaryOutput::to_json

source

fn ConfigCheckSummaryOutput::to_json(ConfigCheckSummaryOutput) -> @moonbitlang/core/json.Json
Json

ConfigCheckSummaryOutput::to_repr

source

fn ConfigCheckSummaryOutput::to_repr(ConfigCheckSummaryOutput) -> @moonbitlang/core/debug.Repr
Repr

ConfigCheckSummaryOutput::to_string

source

fn ConfigCheckSummaryOutput::to_string(self : ConfigCheckSummaryOutput) -> String

ConfigCheckTaskDefinitionInput

source

pub(all) struct ConfigCheckTaskDefinitionInput {
  task_id : String
  node : String?
  needs : Array[String]
  srcs : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigCheckTaskDefinitionInput::equal

source

fn ConfigCheckTaskDefinitionInput::equal(ConfigCheckTaskDefinitionInput, ConfigCheckTaskDefinitionInput) -> Bool

ConfigCheckTaskDefinitionInput::from_json

source

fn ConfigCheckTaskDefinitionInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigCheckTaskDefinitionInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigCheckTaskDefinitionInput::not_equal

source

fn ConfigCheckTaskDefinitionInput::not_equal(x : ConfigCheckTaskDefinitionInput, y : ConfigCheckTaskDefinitionInput) -> Bool

ConfigCheckTaskDefinitionInput::output

source

fn ConfigCheckTaskDefinitionInput::output(ConfigCheckTaskDefinitionInput, &Logger) -> Unit

ConfigCheckTaskDefinitionInput::to_json

source

fn ConfigCheckTaskDefinitionInput::to_json(ConfigCheckTaskDefinitionInput) -> @moonbitlang/core/json.Json
Json

ConfigCheckTaskDefinitionInput::to_repr

source

fn ConfigCheckTaskDefinitionInput::to_repr(ConfigCheckTaskDefinitionInput) -> @moonbitlang/core/debug.Repr
Repr

ConfigCheckTaskDefinitionInput::to_string

source

fn ConfigCheckTaskDefinitionInput::to_string(self : ConfigCheckTaskDefinitionInput) -> String

ConfigOwnershipClaimOutput

source

pub(all) struct ConfigOwnershipClaimOutput {
  task_id : String
  filter : String?
  test_count : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigOwnershipClaimOutput::equal

source

fn ConfigOwnershipClaimOutput::equal(ConfigOwnershipClaimOutput, ConfigOwnershipClaimOutput) -> Bool

ConfigOwnershipClaimOutput::from_json

source

fn ConfigOwnershipClaimOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigOwnershipClaimOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigOwnershipClaimOutput::not_equal

source

fn ConfigOwnershipClaimOutput::not_equal(x : ConfigOwnershipClaimOutput, y : ConfigOwnershipClaimOutput) -> Bool

ConfigOwnershipClaimOutput::output

source

fn ConfigOwnershipClaimOutput::output(ConfigOwnershipClaimOutput, &Logger) -> Unit

ConfigOwnershipClaimOutput::to_json

source

fn ConfigOwnershipClaimOutput::to_json(ConfigOwnershipClaimOutput) -> @moonbitlang/core/json.Json
Json

ConfigOwnershipClaimOutput::to_repr

source

fn ConfigOwnershipClaimOutput::to_repr(ConfigOwnershipClaimOutput) -> @moonbitlang/core/debug.Repr
Repr

ConfigOwnershipClaimOutput::to_string

source

fn ConfigOwnershipClaimOutput::to_string(self : ConfigOwnershipClaimOutput) -> String

ConfigOwnershipEntryOutput

source

pub(all) struct ConfigOwnershipEntryOutput {
  spec : String
  kind : String
  owners : Array[ConfigOwnershipClaimOutput]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigOwnershipEntryOutput::equal

source

fn ConfigOwnershipEntryOutput::equal(ConfigOwnershipEntryOutput, ConfigOwnershipEntryOutput) -> Bool

ConfigOwnershipEntryOutput::from_json

source

fn ConfigOwnershipEntryOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigOwnershipEntryOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigOwnershipEntryOutput::not_equal

source

fn ConfigOwnershipEntryOutput::not_equal(x : ConfigOwnershipEntryOutput, y : ConfigOwnershipEntryOutput) -> Bool

ConfigOwnershipEntryOutput::output

source

fn ConfigOwnershipEntryOutput::output(ConfigOwnershipEntryOutput, &Logger) -> Unit

ConfigOwnershipEntryOutput::to_json

source

fn ConfigOwnershipEntryOutput::to_json(ConfigOwnershipEntryOutput) -> @moonbitlang/core/json.Json
Json

ConfigOwnershipEntryOutput::to_repr

source

fn ConfigOwnershipEntryOutput::to_repr(ConfigOwnershipEntryOutput) -> @moonbitlang/core/debug.Repr
Repr

ConfigOwnershipEntryOutput::to_string

source

fn ConfigOwnershipEntryOutput::to_string(self : ConfigOwnershipEntryOutput) -> String

ConfigTaskSummaryOutput

source

pub(all) struct ConfigTaskSummaryOutput {
  task_id : String
  node : String?
  spec_count : Int
  test_count : Int
  filter_count : Int
  needs_count : Int
  src_count : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ConfigTaskSummaryOutput::equal

source

fn ConfigTaskSummaryOutput::equal(ConfigTaskSummaryOutput, ConfigTaskSummaryOutput) -> Bool

ConfigTaskSummaryOutput::from_json

source

fn ConfigTaskSummaryOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ConfigTaskSummaryOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ConfigTaskSummaryOutput::not_equal

source

fn ConfigTaskSummaryOutput::not_equal(x : ConfigTaskSummaryOutput, y : ConfigTaskSummaryOutput) -> Bool

ConfigTaskSummaryOutput::output

source

fn ConfigTaskSummaryOutput::output(ConfigTaskSummaryOutput, &Logger) -> Unit

ConfigTaskSummaryOutput::to_json

source

fn ConfigTaskSummaryOutput::to_json(ConfigTaskSummaryOutput) -> @moonbitlang/core/json.Json
Json

ConfigTaskSummaryOutput::to_repr

source

fn ConfigTaskSummaryOutput::to_repr(ConfigTaskSummaryOutput) -> @moonbitlang/core/debug.Repr
Repr

ConfigTaskSummaryOutput::to_string

source

fn ConfigTaskSummaryOutput::to_string(self : ConfigTaskSummaryOutput) -> String

DependencyGraphInput

source

pub(all) struct DependencyGraphInput {
  root_dir : String
  nodes : Array[GraphNodeInput]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

DependencyGraphInput::equal

source

fn DependencyGraphInput::equal(DependencyGraphInput, DependencyGraphInput) -> Bool

DependencyGraphInput::from_json

source

fn DependencyGraphInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> DependencyGraphInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

DependencyGraphInput::not_equal

source

fn DependencyGraphInput::not_equal(x : DependencyGraphInput, y : DependencyGraphInput) -> Bool

DependencyGraphInput::output

source

fn DependencyGraphInput::output(DependencyGraphInput, &Logger) -> Unit

DependencyGraphInput::to_json

source

fn DependencyGraphInput::to_json(DependencyGraphInput) -> @moonbitlang/core/json.Json
Json

DependencyGraphInput::to_repr

source

fn DependencyGraphInput::to_repr(DependencyGraphInput) -> @moonbitlang/core/debug.Repr
Repr

DependencyGraphInput::to_string

source

fn DependencyGraphInput::to_string(self : DependencyGraphInput) -> String

DetectInput

source

pub(all) struct DetectInput {
  results : Array[TestRunEntry]
  threshold : Double
  min_runs : Int
} derive(@moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

DetectInput::from_json

source

fn DetectInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> DetectInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

DetectInput::to_json

source

fn DetectInput::to_json(DetectInput) -> @moonbitlang/core/json.Json
Json

DetectOutput

source

pub(all) struct DetectOutput {
  flaky_tests : Array[FlakyResult]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

DetectOutput::equal

source

fn DetectOutput::equal(DetectOutput, DetectOutput) -> Bool

DetectOutput::from_json

source

fn DetectOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> DetectOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

DetectOutput::not_equal

source

fn DetectOutput::not_equal(x : DetectOutput, y : DetectOutput) -> Bool

DetectOutput::output

source

fn DetectOutput::output(DetectOutput, &Logger) -> Unit

DetectOutput::to_json

source

fn DetectOutput::to_json(DetectOutput) -> @moonbitlang/core/json.Json
Json

DetectOutput::to_repr

source

fn DetectOutput::to_repr(DetectOutput) -> @moonbitlang/core/debug.Repr
Repr

DetectOutput::to_string

source

fn DetectOutput::to_string(self : DetectOutput) -> String

EvalCommitSignalInput

source

pub(all) struct EvalCommitSignalInput {
  commit_sha : String
  run_kind : String
  run_count : Int
  distinct_tests : Int
  failure_signals : Int
  duration_ms : Int?
  fallback_used : Bool
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

EvalCommitSignalInput::equal

source

fn EvalCommitSignalInput::equal(EvalCommitSignalInput, EvalCommitSignalInput) -> Bool

EvalCommitSignalInput::from_json

source

fn EvalCommitSignalInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> EvalCommitSignalInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

EvalCommitSignalInput::not_equal

source

fn EvalCommitSignalInput::not_equal(x : EvalCommitSignalInput, y : EvalCommitSignalInput) -> Bool

EvalCommitSignalInput::output

source

fn EvalCommitSignalInput::output(EvalCommitSignalInput, &Logger) -> Unit

EvalCommitSignalInput::to_json

source

fn EvalCommitSignalInput::to_json(EvalCommitSignalInput) -> @moonbitlang/core/json.Json
Json

EvalCommitSignalInput::to_repr

source

fn EvalCommitSignalInput::to_repr(EvalCommitSignalInput) -> @moonbitlang/core/debug.Repr
Repr

EvalCommitSignalInput::to_string

source

fn EvalCommitSignalInput::to_string(self : EvalCommitSignalInput) -> String

FlakyResult

source

pub(all) struct FlakyResult {
  suite : String
  test_name : String
  flaky_rate : Double
  total_runs : Int
  fail_count : Int
  flaky_retry_count : Int
  is_quarantined : Bool
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

FlakyResult::equal

source

fn FlakyResult::equal(FlakyResult, FlakyResult) -> Bool

FlakyResult::from_json

source

fn FlakyResult::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> FlakyResult raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

FlakyResult::not_equal

source

fn FlakyResult::not_equal(x : FlakyResult, y : FlakyResult) -> Bool

FlakyResult::output

source

fn FlakyResult::output(FlakyResult, &Logger) -> Unit

FlakyResult::to_json

source

fn FlakyResult::to_json(FlakyResult) -> @moonbitlang/core/json.Json
Json

FlakyResult::to_repr

source

fn FlakyResult::to_repr(FlakyResult) -> @moonbitlang/core/debug.Repr
Repr

FlakyResult::to_string

source

fn FlakyResult::to_string(self : FlakyResult) -> String

GraphNodeInput

source

pub(all) struct GraphNodeInput {
  id : String
  path : String
  dependencies : Array[String]
  source_patterns : Array[String]
  test_patterns : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

GraphNodeInput::equal

source

fn GraphNodeInput::equal(GraphNodeInput, GraphNodeInput) -> Bool

GraphNodeInput::from_json

source

fn GraphNodeInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> GraphNodeInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

GraphNodeInput::not_equal

source

fn GraphNodeInput::not_equal(x : GraphNodeInput, y : GraphNodeInput) -> Bool

GraphNodeInput::output

source

fn GraphNodeInput::output(GraphNodeInput, &Logger) -> Unit

GraphNodeInput::to_json

source

fn GraphNodeInput::to_json(GraphNodeInput) -> @moonbitlang/core/json.Json
Json

GraphNodeInput::to_repr

source

fn GraphNodeInput::to_repr(GraphNodeInput) -> @moonbitlang/core/debug.Repr
Repr

GraphNodeInput::to_string

source

fn GraphNodeInput::to_string(self : GraphNodeInput) -> String

HoldoutCommitInput

source

pub(all) struct HoldoutCommitInput {
  commit_sha : String
  holdout_tests : Int
  holdout_failures : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

Holdout tests of one commit's local sampled run: tests the sampler held out on purpose, and how many of them failed in CI on the same commit.

HoldoutCommitInput::equal

source

fn HoldoutCommitInput::equal(HoldoutCommitInput, HoldoutCommitInput) -> Bool

HoldoutCommitInput::from_json

source

fn HoldoutCommitInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> HoldoutCommitInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

HoldoutCommitInput::not_equal

source

fn HoldoutCommitInput::not_equal(x : HoldoutCommitInput, y : HoldoutCommitInput) -> Bool

HoldoutCommitInput::output

source

fn HoldoutCommitInput::output(HoldoutCommitInput, &Logger) -> Unit

HoldoutCommitInput::to_json

source

fn HoldoutCommitInput::to_json(HoldoutCommitInput) -> @moonbitlang/core/json.Json
Json

HoldoutCommitInput::to_repr

source

fn HoldoutCommitInput::to_repr(HoldoutCommitInput) -> @moonbitlang/core/debug.Repr
Repr

HoldoutCommitInput::to_string

source

fn HoldoutCommitInput::to_string(self : HoldoutCommitInput) -> String

HoldoutKpiOutput

source

pub(all) struct HoldoutKpiOutput {
  commits : Int
  holdout_tests : Int
  holdout_failures : Int
  false_negative_rate : Double?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

HoldoutKpiOutput::equal

source

fn HoldoutKpiOutput::equal(HoldoutKpiOutput, HoldoutKpiOutput) -> Bool

HoldoutKpiOutput::from_json

source

fn HoldoutKpiOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> HoldoutKpiOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

HoldoutKpiOutput::not_equal

source

fn HoldoutKpiOutput::not_equal(x : HoldoutKpiOutput, y : HoldoutKpiOutput) -> Bool

HoldoutKpiOutput::output

source

fn HoldoutKpiOutput::output(HoldoutKpiOutput, &Logger) -> Unit

HoldoutKpiOutput::to_json

source

fn HoldoutKpiOutput::to_json(HoldoutKpiOutput) -> @moonbitlang/core/json.Json
Json

HoldoutKpiOutput::to_repr

source

fn HoldoutKpiOutput::to_repr(HoldoutKpiOutput) -> @moonbitlang/core/debug.Repr
Repr

HoldoutKpiOutput::to_string

source

fn HoldoutKpiOutput::to_string(self : HoldoutKpiOutput) -> String

QuarantineEntryInput

source

pub(all) struct QuarantineEntryInput {
  id : String
  task_id : String
  spec : String
  title_pattern : String
  mode : String
  scope : String
  owner : String
  reason : String
  condition : String
  introduced_at : String
  expires_at : String
  tracking_issue : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineEntryInput::equal

source

fn QuarantineEntryInput::equal(QuarantineEntryInput, QuarantineEntryInput) -> Bool

QuarantineEntryInput::from_json

source

fn QuarantineEntryInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineEntryInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineEntryInput::not_equal

source

fn QuarantineEntryInput::not_equal(x : QuarantineEntryInput, y : QuarantineEntryInput) -> Bool

QuarantineEntryInput::output

source

fn QuarantineEntryInput::output(QuarantineEntryInput, &Logger) -> Unit

QuarantineEntryInput::to_json

source

fn QuarantineEntryInput::to_json(QuarantineEntryInput) -> @moonbitlang/core/json.Json
Json

QuarantineEntryInput::to_repr

source

fn QuarantineEntryInput::to_repr(QuarantineEntryInput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineEntryInput::to_string

source

fn QuarantineEntryInput::to_string(self : QuarantineEntryInput) -> String

QuarantineIssueOutput

source

pub(all) struct QuarantineIssueOutput {
  severity : String
  code : String
  message : String
  task_id : String?
  spec : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineIssueOutput::equal

source

fn QuarantineIssueOutput::equal(QuarantineIssueOutput, QuarantineIssueOutput) -> Bool

QuarantineIssueOutput::from_json

source

fn QuarantineIssueOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineIssueOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineIssueOutput::not_equal

source

fn QuarantineIssueOutput::not_equal(x : QuarantineIssueOutput, y : QuarantineIssueOutput) -> Bool

QuarantineIssueOutput::output

source

fn QuarantineIssueOutput::output(QuarantineIssueOutput, &Logger) -> Unit

QuarantineIssueOutput::to_json

source

fn QuarantineIssueOutput::to_json(QuarantineIssueOutput) -> @moonbitlang/core/json.Json
Json

QuarantineIssueOutput::to_repr

source

fn QuarantineIssueOutput::to_repr(QuarantineIssueOutput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineIssueOutput::to_string

source

fn QuarantineIssueOutput::to_string(self : QuarantineIssueOutput) -> String

QuarantineModeCountsOutput

source

pub(all) struct QuarantineModeCountsOutput {
  skip : Int
  allow_flaky : Int
  allow_failure : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineModeCountsOutput::equal

source

fn QuarantineModeCountsOutput::equal(QuarantineModeCountsOutput, QuarantineModeCountsOutput) -> Bool

QuarantineModeCountsOutput::from_json

source

fn QuarantineModeCountsOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineModeCountsOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineModeCountsOutput::not_equal

source

fn QuarantineModeCountsOutput::not_equal(x : QuarantineModeCountsOutput, y : QuarantineModeCountsOutput) -> Bool

QuarantineModeCountsOutput::output

source

fn QuarantineModeCountsOutput::output(QuarantineModeCountsOutput, &Logger) -> Unit

QuarantineModeCountsOutput::to_json

source

fn QuarantineModeCountsOutput::to_json(QuarantineModeCountsOutput) -> @moonbitlang/core/json.Json
Json

QuarantineModeCountsOutput::to_repr

source

fn QuarantineModeCountsOutput::to_repr(QuarantineModeCountsOutput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineModeCountsOutput::to_string

source

fn QuarantineModeCountsOutput::to_string(self : QuarantineModeCountsOutput) -> String

QuarantineRuntimeResultInput

source

pub(all) struct QuarantineRuntimeResultInput {
  status : String
  quarantine_mode : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineRuntimeResultInput::equal

source

fn QuarantineRuntimeResultInput::equal(QuarantineRuntimeResultInput, QuarantineRuntimeResultInput) -> Bool

QuarantineRuntimeResultInput::from_json

source

fn QuarantineRuntimeResultInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineRuntimeResultInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineRuntimeResultInput::not_equal

source

fn QuarantineRuntimeResultInput::not_equal(x : QuarantineRuntimeResultInput, y : QuarantineRuntimeResultInput) -> Bool

QuarantineRuntimeResultInput::output

source

fn QuarantineRuntimeResultInput::output(QuarantineRuntimeResultInput, &Logger) -> Unit

QuarantineRuntimeResultInput::to_json

source

fn QuarantineRuntimeResultInput::to_json(QuarantineRuntimeResultInput) -> @moonbitlang/core/json.Json
Json

QuarantineRuntimeResultInput::to_repr

source

fn QuarantineRuntimeResultInput::to_repr(QuarantineRuntimeResultInput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineRuntimeResultInput::to_string

source

fn QuarantineRuntimeResultInput::to_string(self : QuarantineRuntimeResultInput) -> String

QuarantineScopeCountsOutput

source

pub(all) struct QuarantineScopeCountsOutput {
  environment : Int
  flaky : Int
  expected_failure : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineScopeCountsOutput::equal

source

fn QuarantineScopeCountsOutput::equal(QuarantineScopeCountsOutput, QuarantineScopeCountsOutput) -> Bool

QuarantineScopeCountsOutput::from_json

source

fn QuarantineScopeCountsOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineScopeCountsOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineScopeCountsOutput::not_equal

source

fn QuarantineScopeCountsOutput::not_equal(x : QuarantineScopeCountsOutput, y : QuarantineScopeCountsOutput) -> Bool

QuarantineScopeCountsOutput::output

source

fn QuarantineScopeCountsOutput::output(QuarantineScopeCountsOutput, &Logger) -> Unit

QuarantineScopeCountsOutput::to_json

source

fn QuarantineScopeCountsOutput::to_json(QuarantineScopeCountsOutput) -> @moonbitlang/core/json.Json
Json

QuarantineScopeCountsOutput::to_repr

source

fn QuarantineScopeCountsOutput::to_repr(QuarantineScopeCountsOutput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineScopeCountsOutput::to_string

source

fn QuarantineScopeCountsOutput::to_string(self : QuarantineScopeCountsOutput) -> String

QuarantineSummaryCoreOutput

source

pub(all) struct QuarantineSummaryCoreOutput {
  entry_count : Int
  mode_counts : QuarantineModeCountsOutput
  scope_counts : QuarantineScopeCountsOutput
  entries : Array[ResolvedQuarantineEntryOutput]
  errors : Array[QuarantineIssueOutput]
  warnings : Array[QuarantineIssueOutput]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineSummaryCoreOutput::equal

source

fn QuarantineSummaryCoreOutput::equal(QuarantineSummaryCoreOutput, QuarantineSummaryCoreOutput) -> Bool

QuarantineSummaryCoreOutput::from_json

source

fn QuarantineSummaryCoreOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineSummaryCoreOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineSummaryCoreOutput::not_equal

source

fn QuarantineSummaryCoreOutput::not_equal(x : QuarantineSummaryCoreOutput, y : QuarantineSummaryCoreOutput) -> Bool

QuarantineSummaryCoreOutput::output

source

fn QuarantineSummaryCoreOutput::output(QuarantineSummaryCoreOutput, &Logger) -> Unit

QuarantineSummaryCoreOutput::to_json

source

fn QuarantineSummaryCoreOutput::to_json(QuarantineSummaryCoreOutput) -> @moonbitlang/core/json.Json
Json

QuarantineSummaryCoreOutput::to_repr

source

fn QuarantineSummaryCoreOutput::to_repr(QuarantineSummaryCoreOutput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineSummaryCoreOutput::to_string

source

fn QuarantineSummaryCoreOutput::to_string(self : QuarantineSummaryCoreOutput) -> String

QuarantineTaskOwnershipInput

source

pub(all) struct QuarantineTaskOwnershipInput {
  id : String
  specs : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

QuarantineTaskOwnershipInput::equal

source

fn QuarantineTaskOwnershipInput::equal(QuarantineTaskOwnershipInput, QuarantineTaskOwnershipInput) -> Bool

QuarantineTaskOwnershipInput::from_json

source

fn QuarantineTaskOwnershipInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> QuarantineTaskOwnershipInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

QuarantineTaskOwnershipInput::not_equal

source

fn QuarantineTaskOwnershipInput::not_equal(x : QuarantineTaskOwnershipInput, y : QuarantineTaskOwnershipInput) -> Bool

QuarantineTaskOwnershipInput::output

source

fn QuarantineTaskOwnershipInput::output(QuarantineTaskOwnershipInput, &Logger) -> Unit

QuarantineTaskOwnershipInput::to_json

source

fn QuarantineTaskOwnershipInput::to_json(QuarantineTaskOwnershipInput) -> @moonbitlang/core/json.Json
Json

QuarantineTaskOwnershipInput::to_repr

source

fn QuarantineTaskOwnershipInput::to_repr(QuarantineTaskOwnershipInput) -> @moonbitlang/core/debug.Repr
Repr

QuarantineTaskOwnershipInput::to_string

source

fn QuarantineTaskOwnershipInput::to_string(self : QuarantineTaskOwnershipInput) -> String

ReportAggregateOutput

source

pub(all) struct ReportAggregateOutput {
  shard_count : Int
  unstable_count : Int
  totals : ReportTotalsInput
  unstable : Array[ReportAggregateUnstableBuckets]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportAggregateOutput::equal

source

fn ReportAggregateOutput::equal(ReportAggregateOutput, ReportAggregateOutput) -> Bool

ReportAggregateOutput::from_json

source

fn ReportAggregateOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportAggregateOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportAggregateOutput::not_equal

source

fn ReportAggregateOutput::not_equal(x : ReportAggregateOutput, y : ReportAggregateOutput) -> Bool

ReportAggregateOutput::output

source

fn ReportAggregateOutput::output(ReportAggregateOutput, &Logger) -> Unit

ReportAggregateOutput::to_json

source

fn ReportAggregateOutput::to_json(ReportAggregateOutput) -> @moonbitlang/core/json.Json
Json

ReportAggregateOutput::to_repr

source

fn ReportAggregateOutput::to_repr(ReportAggregateOutput) -> @moonbitlang/core/debug.Repr
Repr

ReportAggregateOutput::to_string

source

fn ReportAggregateOutput::to_string(self : ReportAggregateOutput) -> String

ReportAggregateShardInput

source

pub(all) struct ReportAggregateShardInput {
  shard_id : String
  totals : ReportTotalsInput
  unstable : Array[ReportAggregateUnstableStatusInput]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportAggregateShardInput::equal

source

fn ReportAggregateShardInput::equal(ReportAggregateShardInput, ReportAggregateShardInput) -> Bool

ReportAggregateShardInput::from_json

source

fn ReportAggregateShardInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportAggregateShardInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportAggregateShardInput::not_equal

source

fn ReportAggregateShardInput::not_equal(x : ReportAggregateShardInput, y : ReportAggregateShardInput) -> Bool

ReportAggregateShardInput::output

source

fn ReportAggregateShardInput::output(ReportAggregateShardInput, &Logger) -> Unit

ReportAggregateShardInput::to_json

source

fn ReportAggregateShardInput::to_json(ReportAggregateShardInput) -> @moonbitlang/core/json.Json
Json

ReportAggregateShardInput::to_repr

source

fn ReportAggregateShardInput::to_repr(ReportAggregateShardInput) -> @moonbitlang/core/debug.Repr
Repr

ReportAggregateShardInput::to_string

source

fn ReportAggregateShardInput::to_string(self : ReportAggregateShardInput) -> String

ReportAggregateUnstableBuckets

source

pub(all) struct ReportAggregateUnstableBuckets {
  test_id : String
  shard_ids : Array[String]
  statuses : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportAggregateUnstableBuckets::equal

source

fn ReportAggregateUnstableBuckets::equal(ReportAggregateUnstableBuckets, ReportAggregateUnstableBuckets) -> Bool

ReportAggregateUnstableBuckets::from_json

source

fn ReportAggregateUnstableBuckets::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportAggregateUnstableBuckets raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportAggregateUnstableBuckets::not_equal

source

fn ReportAggregateUnstableBuckets::not_equal(x : ReportAggregateUnstableBuckets, y : ReportAggregateUnstableBuckets) -> Bool

ReportAggregateUnstableBuckets::output

source

fn ReportAggregateUnstableBuckets::output(ReportAggregateUnstableBuckets, &Logger) -> Unit

ReportAggregateUnstableBuckets::to_json

source

fn ReportAggregateUnstableBuckets::to_json(ReportAggregateUnstableBuckets) -> @moonbitlang/core/json.Json
Json

ReportAggregateUnstableBuckets::to_repr

source

fn ReportAggregateUnstableBuckets::to_repr(ReportAggregateUnstableBuckets) -> @moonbitlang/core/debug.Repr
Repr

ReportAggregateUnstableBuckets::to_string

source

fn ReportAggregateUnstableBuckets::to_string(self : ReportAggregateUnstableBuckets) -> String

ReportAggregateUnstableStatusInput

source

pub(all) struct ReportAggregateUnstableStatusInput {
  test_id : String
  status : String
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportAggregateUnstableStatusInput::equal

source

fn ReportAggregateUnstableStatusInput::equal(ReportAggregateUnstableStatusInput, ReportAggregateUnstableStatusInput) -> Bool

ReportAggregateUnstableStatusInput::from_json

source

fn ReportAggregateUnstableStatusInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportAggregateUnstableStatusInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportAggregateUnstableStatusInput::not_equal

source

fn ReportAggregateUnstableStatusInput::not_equal(x : ReportAggregateUnstableStatusInput, y : ReportAggregateUnstableStatusInput) -> Bool

ReportAggregateUnstableStatusInput::output

source

fn ReportAggregateUnstableStatusInput::output(ReportAggregateUnstableStatusInput, &Logger) -> Unit

ReportAggregateUnstableStatusInput::to_json

source

fn ReportAggregateUnstableStatusInput::to_json(ReportAggregateUnstableStatusInput) -> @moonbitlang/core/json.Json
Json

ReportAggregateUnstableStatusInput::to_repr

source

fn ReportAggregateUnstableStatusInput::to_repr(ReportAggregateUnstableStatusInput) -> @moonbitlang/core/debug.Repr
Repr

ReportAggregateUnstableStatusInput::to_string

source

fn ReportAggregateUnstableStatusInput::to_string(self : ReportAggregateUnstableStatusInput) -> String

ReportDiffBuckets

source

pub(all) struct ReportDiffBuckets {
  new_failures : Array[String]
  new_flaky : Array[String]
  resolved_failures : Array[String]
  resolved_flaky : Array[String]
  persistent_flaky : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportDiffBuckets::equal

source

fn ReportDiffBuckets::equal(ReportDiffBuckets, ReportDiffBuckets) -> Bool

ReportDiffBuckets::from_json

source

fn ReportDiffBuckets::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportDiffBuckets raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportDiffBuckets::not_equal

source

fn ReportDiffBuckets::not_equal(x : ReportDiffBuckets, y : ReportDiffBuckets) -> Bool

ReportDiffBuckets::output

source

fn ReportDiffBuckets::output(ReportDiffBuckets, &Logger) -> Unit

ReportDiffBuckets::to_json

source

fn ReportDiffBuckets::to_json(ReportDiffBuckets) -> @moonbitlang/core/json.Json
Json

ReportDiffBuckets::to_repr

source

fn ReportDiffBuckets::to_repr(ReportDiffBuckets) -> @moonbitlang/core/debug.Repr
Repr

ReportDiffBuckets::to_string

source

fn ReportDiffBuckets::to_string(self : ReportDiffBuckets) -> String

ReportDiffStatusInput

source

pub(all) struct ReportDiffStatusInput {
  test_id : String
  base_status : String
  head_status : String
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportDiffStatusInput::equal

source

fn ReportDiffStatusInput::equal(ReportDiffStatusInput, ReportDiffStatusInput) -> Bool

ReportDiffStatusInput::from_json

source

fn ReportDiffStatusInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportDiffStatusInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportDiffStatusInput::not_equal

source

fn ReportDiffStatusInput::not_equal(x : ReportDiffStatusInput, y : ReportDiffStatusInput) -> Bool

ReportDiffStatusInput::output

source

fn ReportDiffStatusInput::output(ReportDiffStatusInput, &Logger) -> Unit

ReportDiffStatusInput::to_json

source

fn ReportDiffStatusInput::to_json(ReportDiffStatusInput) -> @moonbitlang/core/json.Json
Json

ReportDiffStatusInput::to_repr

source

fn ReportDiffStatusInput::to_repr(ReportDiffStatusInput) -> @moonbitlang/core/debug.Repr
Repr

ReportDiffStatusInput::to_string

source

fn ReportDiffStatusInput::to_string(self : ReportDiffStatusInput) -> String

ReportFileTotalsOutput

source

pub(all) struct ReportFileTotalsOutput {
  suite : String
  totals : ReportTotalsInput
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportFileTotalsOutput::equal

source

fn ReportFileTotalsOutput::equal(ReportFileTotalsOutput, ReportFileTotalsOutput) -> Bool

ReportFileTotalsOutput::from_json

source

fn ReportFileTotalsOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportFileTotalsOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportFileTotalsOutput::not_equal

source

fn ReportFileTotalsOutput::not_equal(x : ReportFileTotalsOutput, y : ReportFileTotalsOutput) -> Bool

ReportFileTotalsOutput::output

source

fn ReportFileTotalsOutput::output(ReportFileTotalsOutput, &Logger) -> Unit

ReportFileTotalsOutput::to_json

source

fn ReportFileTotalsOutput::to_json(ReportFileTotalsOutput) -> @moonbitlang/core/json.Json
Json

ReportFileTotalsOutput::to_repr

source

fn ReportFileTotalsOutput::to_repr(ReportFileTotalsOutput) -> @moonbitlang/core/debug.Repr
Repr

ReportFileTotalsOutput::to_string

source

fn ReportFileTotalsOutput::to_string(self : ReportFileTotalsOutput) -> String

ReportSummaryOutput

source

pub(all) struct ReportSummaryOutput {
  totals : ReportTotalsInput
  file_totals : Array[ReportFileTotalsOutput]
  unstable_test_ids : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportSummaryOutput::equal

source

fn ReportSummaryOutput::equal(ReportSummaryOutput, ReportSummaryOutput) -> Bool

ReportSummaryOutput::from_json

source

fn ReportSummaryOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportSummaryOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportSummaryOutput::not_equal

source

fn ReportSummaryOutput::not_equal(x : ReportSummaryOutput, y : ReportSummaryOutput) -> Bool

ReportSummaryOutput::output

source

fn ReportSummaryOutput::output(ReportSummaryOutput, &Logger) -> Unit

ReportSummaryOutput::to_json

source

fn ReportSummaryOutput::to_json(ReportSummaryOutput) -> @moonbitlang/core/json.Json
Json

ReportSummaryOutput::to_repr

source

fn ReportSummaryOutput::to_repr(ReportSummaryOutput) -> @moonbitlang/core/debug.Repr
Repr

ReportSummaryOutput::to_string

source

fn ReportSummaryOutput::to_string(self : ReportSummaryOutput) -> String

ReportSummaryTestInput

source

pub(all) struct ReportSummaryTestInput {
  test_id : String
  suite : String
  status : String
  duration_ms : Int
  retry_count : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportSummaryTestInput::equal

source

fn ReportSummaryTestInput::equal(ReportSummaryTestInput, ReportSummaryTestInput) -> Bool

ReportSummaryTestInput::from_json

source

fn ReportSummaryTestInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportSummaryTestInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportSummaryTestInput::not_equal

source

fn ReportSummaryTestInput::not_equal(x : ReportSummaryTestInput, y : ReportSummaryTestInput) -> Bool

ReportSummaryTestInput::output

source

fn ReportSummaryTestInput::output(ReportSummaryTestInput, &Logger) -> Unit

ReportSummaryTestInput::to_json

source

fn ReportSummaryTestInput::to_json(ReportSummaryTestInput) -> @moonbitlang/core/json.Json
Json

ReportSummaryTestInput::to_repr

source

fn ReportSummaryTestInput::to_repr(ReportSummaryTestInput) -> @moonbitlang/core/debug.Repr
Repr

ReportSummaryTestInput::to_string

source

fn ReportSummaryTestInput::to_string(self : ReportSummaryTestInput) -> String

ReportTotalsInput

source

pub(all) struct ReportTotalsInput {
  total : Int
  passed : Int
  failed : Int
  flaky : Int
  skipped : Int
  retries : Int
  duration_ms : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReportTotalsInput::equal

source

fn ReportTotalsInput::equal(ReportTotalsInput, ReportTotalsInput) -> Bool

ReportTotalsInput::from_json

source

fn ReportTotalsInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReportTotalsInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReportTotalsInput::not_equal

source

fn ReportTotalsInput::not_equal(x : ReportTotalsInput, y : ReportTotalsInput) -> Bool

ReportTotalsInput::output

source

fn ReportTotalsInput::output(ReportTotalsInput, &Logger) -> Unit

ReportTotalsInput::to_json

source

fn ReportTotalsInput::to_json(ReportTotalsInput) -> @moonbitlang/core/json.Json
Json

ReportTotalsInput::to_repr

source

fn ReportTotalsInput::to_repr(ReportTotalsInput) -> @moonbitlang/core/debug.Repr
Repr

ReportTotalsInput::to_string

source

fn ReportTotalsInput::to_string(self : ReportTotalsInput) -> String

ResolvedQuarantineEntryOutput

source

pub(all) struct ResolvedQuarantineEntryOutput {
  id : String
  task_id : String
  spec : String
  title_pattern : String
  mode : String
  scope : String
  owner : String
  reason : String
  condition : String
  introduced_at : String
  expires_at : String
  tracking_issue : String?
  expiry_status : String
  days_until_expiry : Int?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ResolvedQuarantineEntryOutput::equal

source

fn ResolvedQuarantineEntryOutput::equal(ResolvedQuarantineEntryOutput, ResolvedQuarantineEntryOutput) -> Bool

ResolvedQuarantineEntryOutput::from_json

source

fn ResolvedQuarantineEntryOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ResolvedQuarantineEntryOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ResolvedQuarantineEntryOutput::not_equal

source

fn ResolvedQuarantineEntryOutput::not_equal(x : ResolvedQuarantineEntryOutput, y : ResolvedQuarantineEntryOutput) -> Bool

ResolvedQuarantineEntryOutput::output

source

fn ResolvedQuarantineEntryOutput::output(ResolvedQuarantineEntryOutput, &Logger) -> Unit

ResolvedQuarantineEntryOutput::to_json

source

fn ResolvedQuarantineEntryOutput::to_json(ResolvedQuarantineEntryOutput) -> @moonbitlang/core/json.Json
Json

ResolvedQuarantineEntryOutput::to_repr

source

fn ResolvedQuarantineEntryOutput::to_repr(ResolvedQuarantineEntryOutput) -> @moonbitlang/core/debug.Repr
Repr

ResolvedQuarantineEntryOutput::to_string

source

fn ResolvedQuarantineEntryOutput::to_string(self : ResolvedQuarantineEntryOutput) -> String

ResolvedStableTestIdentityOutput

source

pub(all) struct ResolvedStableTestIdentityOutput {
  suite : String
  test_name : String
  task_id : String
  filter : String?
  variant : Array[StableVariantEntryInput]?
  test_id : String
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ResolvedStableTestIdentityOutput::equal

source

fn ResolvedStableTestIdentityOutput::equal(ResolvedStableTestIdentityOutput, ResolvedStableTestIdentityOutput) -> Bool

ResolvedStableTestIdentityOutput::from_json

source

fn ResolvedStableTestIdentityOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ResolvedStableTestIdentityOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ResolvedStableTestIdentityOutput::not_equal

source

fn ResolvedStableTestIdentityOutput::not_equal(x : ResolvedStableTestIdentityOutput, y : ResolvedStableTestIdentityOutput) -> Bool

ResolvedStableTestIdentityOutput::output

source

fn ResolvedStableTestIdentityOutput::output(ResolvedStableTestIdentityOutput, &Logger) -> Unit

ResolvedStableTestIdentityOutput::to_json

source

fn ResolvedStableTestIdentityOutput::to_json(ResolvedStableTestIdentityOutput) -> @moonbitlang/core/json.Json
Json

ResolvedStableTestIdentityOutput::to_repr

source

fn ResolvedStableTestIdentityOutput::to_repr(ResolvedStableTestIdentityOutput) -> @moonbitlang/core/debug.Repr
Repr

ResolvedStableTestIdentityOutput::to_string

source

fn ResolvedStableTestIdentityOutput::to_string(self : ResolvedStableTestIdentityOutput) -> String

ReverseDepEntry

source

pub(all) struct ReverseDepEntry {
  id : String
  dependents : Array[String]
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

ReverseDepEntry::equal

source

fn ReverseDepEntry::equal(ReverseDepEntry, ReverseDepEntry) -> Bool

ReverseDepEntry::from_json

source

fn ReverseDepEntry::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> ReverseDepEntry raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

ReverseDepEntry::not_equal

source

fn ReverseDepEntry::not_equal(x : ReverseDepEntry, y : ReverseDepEntry) -> Bool

ReverseDepEntry::output

source

fn ReverseDepEntry::output(ReverseDepEntry, &Logger) -> Unit

ReverseDepEntry::to_json

source

fn ReverseDepEntry::to_json(ReverseDepEntry) -> @moonbitlang/core/json.Json
Json

ReverseDepEntry::to_repr

source

fn ReverseDepEntry::to_repr(ReverseDepEntry) -> @moonbitlang/core/debug.Repr
Repr

ReverseDepEntry::to_string

source

fn ReverseDepEntry::to_string(self : ReverseDepEntry) -> String

SamplingHistoryRowInput

source

pub(all) struct SamplingHistoryRowInput {
  suite : String
  test_name : String
  task_id : String?
  filter : String?
  variant : Array[StableVariantEntryInput]?
  test_id : String?
  status : String
  retry_count : Int
  duration_ms : Int
  created_at : String
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

SamplingHistoryRowInput::equal

source

fn SamplingHistoryRowInput::equal(SamplingHistoryRowInput, SamplingHistoryRowInput) -> Bool

SamplingHistoryRowInput::from_json

source

fn SamplingHistoryRowInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingHistoryRowInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingHistoryRowInput::not_equal

source

fn SamplingHistoryRowInput::not_equal(x : SamplingHistoryRowInput, y : SamplingHistoryRowInput) -> Bool

SamplingHistoryRowInput::output

source

fn SamplingHistoryRowInput::output(SamplingHistoryRowInput, &Logger) -> Unit

SamplingHistoryRowInput::to_json

source

fn SamplingHistoryRowInput::to_json(SamplingHistoryRowInput) -> @moonbitlang/core/json.Json
Json

SamplingHistoryRowInput::to_repr

source

fn SamplingHistoryRowInput::to_repr(SamplingHistoryRowInput) -> @moonbitlang/core/debug.Repr
Repr

SamplingHistoryRowInput::to_string

source

fn SamplingHistoryRowInput::to_string(self : SamplingHistoryRowInput) -> String

SamplingKpiConfusionMatrixOutput

source

pub(all) struct SamplingKpiConfusionMatrixOutput {
  true_positive : Int
  false_positive : Int
  false_negative : Int
  true_negative : Int
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

SamplingKpiConfusionMatrixOutput::equal

source

fn SamplingKpiConfusionMatrixOutput::equal(SamplingKpiConfusionMatrixOutput, SamplingKpiConfusionMatrixOutput) -> Bool

SamplingKpiConfusionMatrixOutput::from_json

source

fn SamplingKpiConfusionMatrixOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingKpiConfusionMatrixOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingKpiConfusionMatrixOutput::not_equal

source

fn SamplingKpiConfusionMatrixOutput::not_equal(x : SamplingKpiConfusionMatrixOutput, y : SamplingKpiConfusionMatrixOutput) -> Bool

SamplingKpiConfusionMatrixOutput::output

source

fn SamplingKpiConfusionMatrixOutput::output(SamplingKpiConfusionMatrixOutput, &Logger) -> Unit

SamplingKpiConfusionMatrixOutput::to_json

source

fn SamplingKpiConfusionMatrixOutput::to_json(SamplingKpiConfusionMatrixOutput) -> @moonbitlang/core/json.Json
Json

SamplingKpiConfusionMatrixOutput::to_repr

source

fn SamplingKpiConfusionMatrixOutput::to_repr(SamplingKpiConfusionMatrixOutput) -> @moonbitlang/core/debug.Repr
Repr

SamplingKpiConfusionMatrixOutput::to_string

source

fn SamplingKpiConfusionMatrixOutput::to_string(self : SamplingKpiConfusionMatrixOutput) -> String

SamplingKpiMissesOutput

source

pub(all) struct SamplingKpiMissesOutput {
  local_pass_but_ci_fail : Int
  local_fail_but_ci_pass : Int
  false_negative_rate : Double?
  false_positive_rate : Double?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

SamplingKpiMissesOutput::equal

source

fn SamplingKpiMissesOutput::equal(SamplingKpiMissesOutput, SamplingKpiMissesOutput) -> Bool

SamplingKpiMissesOutput::from_json

source

fn SamplingKpiMissesOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingKpiMissesOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingKpiMissesOutput::not_equal

source

fn SamplingKpiMissesOutput::not_equal(x : SamplingKpiMissesOutput, y : SamplingKpiMissesOutput) -> Bool

SamplingKpiMissesOutput::output

source

fn SamplingKpiMissesOutput::output(SamplingKpiMissesOutput, &Logger) -> Unit

SamplingKpiMissesOutput::to_json

source

fn SamplingKpiMissesOutput::to_json(SamplingKpiMissesOutput) -> @moonbitlang/core/json.Json
Json

SamplingKpiMissesOutput::to_repr

source

fn SamplingKpiMissesOutput::to_repr(SamplingKpiMissesOutput) -> @moonbitlang/core/debug.Repr
Repr

SamplingKpiMissesOutput::to_string

source

fn SamplingKpiMissesOutput::to_string(self : SamplingKpiMissesOutput) -> String

SamplingKpiOutput

source

pub(all) struct SamplingKpiOutput {
  matched_commits : Int
  local_only_commits : Int
  ci_only_commits : Int
  avg_local_sample_size : Double?
  median_local_sample_size : Double?
  p95_local_sample_size : Double?
  avg_ci_test_count : Double?
  avg_sample_ratio : Double?
  avg_saved_minutes : Double?
  fallback_runs : Int
  fallback_rate : Double?
  pass_signal : SamplingKpiSignalOutput
  fail_signal : SamplingKpiSignalOutput
  misses : SamplingKpiMissesOutput
  confusion_matrix : SamplingKpiConfusionMatrixOutput
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

SamplingKpiOutput::equal

source

fn SamplingKpiOutput::equal(SamplingKpiOutput, SamplingKpiOutput) -> Bool

SamplingKpiOutput::from_json

source

fn SamplingKpiOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingKpiOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingKpiOutput::not_equal

source

fn SamplingKpiOutput::not_equal(x : SamplingKpiOutput, y : SamplingKpiOutput) -> Bool

SamplingKpiOutput::output

source

fn SamplingKpiOutput::output(SamplingKpiOutput, &Logger) -> Unit

SamplingKpiOutput::to_json

source

fn SamplingKpiOutput::to_json(SamplingKpiOutput) -> @moonbitlang/core/json.Json
Json

SamplingKpiOutput::to_repr

source

fn SamplingKpiOutput::to_repr(SamplingKpiOutput) -> @moonbitlang/core/debug.Repr
Repr

SamplingKpiOutput::to_string

source

fn SamplingKpiOutput::to_string(self : SamplingKpiOutput) -> String

SamplingKpiSignalOutput

source

pub(all) struct SamplingKpiSignalOutput {
  local_commits : Int
  ci_when_local : Int
  rate : Double?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

SamplingKpiSignalOutput::equal

source

fn SamplingKpiSignalOutput::equal(SamplingKpiSignalOutput, SamplingKpiSignalOutput) -> Bool

SamplingKpiSignalOutput::from_json

source

fn SamplingKpiSignalOutput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingKpiSignalOutput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingKpiSignalOutput::not_equal

source

fn SamplingKpiSignalOutput::not_equal(x : SamplingKpiSignalOutput, y : SamplingKpiSignalOutput) -> Bool

SamplingKpiSignalOutput::output

source

fn SamplingKpiSignalOutput::output(SamplingKpiSignalOutput, &Logger) -> Unit

SamplingKpiSignalOutput::to_json

source

fn SamplingKpiSignalOutput::to_json(SamplingKpiSignalOutput) -> @moonbitlang/core/json.Json
Json

SamplingKpiSignalOutput::to_repr

source

fn SamplingKpiSignalOutput::to_repr(SamplingKpiSignalOutput) -> @moonbitlang/core/debug.Repr
Repr

SamplingKpiSignalOutput::to_string

source

fn SamplingKpiSignalOutput::to_string(self : SamplingKpiSignalOutput) -> String

SamplingListedTestInput

source

pub(all) struct SamplingListedTestInput {
  suite : String
  test_name : String
  task_id : String?
  filter : String?
  variant : Array[StableVariantEntryInput]?
  test_id : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

SamplingListedTestInput::equal

source

fn SamplingListedTestInput::equal(SamplingListedTestInput, SamplingListedTestInput) -> Bool

SamplingListedTestInput::from_json

source

fn SamplingListedTestInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> SamplingListedTestInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

SamplingListedTestInput::not_equal

source

fn SamplingListedTestInput::not_equal(x : SamplingListedTestInput, y : SamplingListedTestInput) -> Bool

SamplingListedTestInput::output

source

fn SamplingListedTestInput::output(SamplingListedTestInput, &Logger) -> Unit

SamplingListedTestInput::to_json

source

fn SamplingListedTestInput::to_json(SamplingListedTestInput) -> @moonbitlang/core/json.Json
Json

SamplingListedTestInput::to_repr

source

fn SamplingListedTestInput::to_repr(SamplingListedTestInput) -> @moonbitlang/core/debug.Repr
Repr

SamplingListedTestInput::to_string

source

fn SamplingListedTestInput::to_string(self : SamplingListedTestInput) -> String

StableTestIdentityInput

source

pub(all) struct StableTestIdentityInput {
  suite : String
  test_name : String
  task_id : String?
  filter : String?
  variant : Array[StableVariantEntryInput]?
  test_id : String?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

StableTestIdentityInput::equal

source

fn StableTestIdentityInput::equal(StableTestIdentityInput, StableTestIdentityInput) -> Bool

StableTestIdentityInput::from_json

source

fn StableTestIdentityInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> StableTestIdentityInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

StableTestIdentityInput::not_equal

source

fn StableTestIdentityInput::not_equal(x : StableTestIdentityInput, y : StableTestIdentityInput) -> Bool

StableTestIdentityInput::output

source

fn StableTestIdentityInput::output(StableTestIdentityInput, &Logger) -> Unit

StableTestIdentityInput::to_json

source

fn StableTestIdentityInput::to_json(StableTestIdentityInput) -> @moonbitlang/core/json.Json
Json

StableTestIdentityInput::to_repr

source

fn StableTestIdentityInput::to_repr(StableTestIdentityInput) -> @moonbitlang/core/debug.Repr
Repr

StableTestIdentityInput::to_string

source

fn StableTestIdentityInput::to_string(self : StableTestIdentityInput) -> String

StableVariantEntryInput

source

pub(all) struct StableVariantEntryInput {
  key : String
  value : String
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

StableVariantEntryInput::equal

source

fn StableVariantEntryInput::equal(StableVariantEntryInput, StableVariantEntryInput) -> Bool

StableVariantEntryInput::from_json

source

fn StableVariantEntryInput::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> StableVariantEntryInput raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

StableVariantEntryInput::not_equal

source

fn StableVariantEntryInput::not_equal(x : StableVariantEntryInput, y : StableVariantEntryInput) -> Bool

StableVariantEntryInput::output

source

fn StableVariantEntryInput::output(StableVariantEntryInput, &Logger) -> Unit

StableVariantEntryInput::to_json

source

fn StableVariantEntryInput::to_json(StableVariantEntryInput) -> @moonbitlang/core/json.Json
Json

StableVariantEntryInput::to_repr

source

fn StableVariantEntryInput::to_repr(StableVariantEntryInput) -> @moonbitlang/core/debug.Repr
Repr

StableVariantEntryInput::to_string

source

fn StableVariantEntryInput::to_string(self : StableVariantEntryInput) -> String

TestMeta

source

pub(all) struct TestMeta {
  suite : String
  test_name : String
  flaky_rate : Double
  total_runs : Int
  fail_count : Int
  last_run_at : String
  avg_duration_ms : Int
  previously_failed : Bool
  is_new : Bool
  task_id : String?
  filter : String?
  test_id : String?
  co_failure_boost : Double?
} derive(Eq, Show, @moonbitlang/core/debug.Debug
Debug, @moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

TestMeta::equal

source

fn TestMeta::equal(TestMeta, TestMeta) -> Bool

TestMeta::from_json

source

fn TestMeta::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> TestMeta raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

TestMeta::not_equal

source

fn TestMeta::not_equal(x : TestMeta, y : TestMeta) -> Bool

TestMeta::output

source

fn TestMeta::output(TestMeta, &Logger) -> Unit

TestMeta::to_json

source

fn TestMeta::to_json(TestMeta) -> @moonbitlang/core/json.Json
Json

TestMeta::to_repr

source

fn TestMeta::to_repr(TestMeta) -> @moonbitlang/core/debug.Repr
Repr

TestMeta::to_string

source

fn TestMeta::to_string(self : TestMeta) -> String

TestRunEntry

source

pub(all) struct TestRunEntry {
  suite : String
  test_name : String
  status : String
  retry_count : Int
} derive(@moonbitlang/core/json.FromJson
FromJson, @moonbitlang/core/json.ToJson
ToJson)

TestRunEntry::from_json

source

fn TestRunEntry::from_json(@moonbitlang/core/json.Json
Json, @moonbitlang/core/json.JsonPath
JsonPath) -> TestRunEntry raise @moonbitlang/core/json.JsonDecodeError
JsonDecodeError

TestRunEntry::to_json

source

fn TestRunEntry::to_json(TestRunEntry) -> @moonbitlang/core/json.Json
Json

Source Files

Install

Download zip

flaker core computation engine

mizchi

MIT

github.com/mizchi/flaker

Updated yesterday

106 downloads

#AffectedDirectSelectionInput

#AffectedDirectSelectionInput::equal

#AffectedDirectSelectionInput::from_json

#AffectedDirectSelectionInput::not_equal

#AffectedDirectSelectionInput::output

#AffectedDirectSelectionInput::to_json

#AffectedDirectSelectionInput::to_repr

#AffectedDirectSelectionInput::to_string

#AffectedReportCoreOutput

#AffectedReportCoreOutput::equal

#AffectedReportCoreOutput::from_json

#AffectedReportCoreOutput::not_equal

#AffectedReportCoreOutput::output

#AffectedReportCoreOutput::to_json

#AffectedReportCoreOutput::to_repr

#AffectedReportCoreOutput::to_string

#AffectedReportInput

#AffectedReportInput::equal

#AffectedReportInput::from_json

#AffectedReportInput::not_equal

#AffectedReportInput::output

#AffectedReportInput::to_json

#AffectedReportInput::to_repr

#AffectedReportInput::to_string

#AffectedReportSummaryOutput

#AffectedReportSummaryOutput::equal

#AffectedReportSummaryOutput::from_json

#AffectedReportSummaryOutput::not_equal

#AffectedReportSummaryOutput::output

#AffectedReportSummaryOutput::to_json

#AffectedReportSummaryOutput::to_repr

#AffectedReportSummaryOutput::to_string

#AffectedSelectionOutput

#AffectedSelectionOutput::equal

#AffectedSelectionOutput::from_json

#AffectedSelectionOutput::not_equal

#AffectedSelectionOutput::output

#AffectedSelectionOutput::to_json

#AffectedSelectionOutput::to_repr

#AffectedSelectionOutput::to_string

#AffectedTargetInput

#AffectedTargetInput::equal

#AffectedTargetInput::from_json

#AffectedTargetInput::not_equal

#AffectedTargetInput::output

#AffectedTargetInput::to_json

#AffectedTargetInput::to_repr

#AffectedTargetInput::to_string

#AffectedTransitiveTaskInput

#AffectedTransitiveTaskInput::equal

#AffectedTransitiveTaskInput::from_json

#AffectedTransitiveTaskInput::not_equal

#AffectedTransitiveTaskInput::output

#AffectedTransitiveTaskInput::to_json

#AffectedTransitiveTaskInput::to_repr

#AffectedTransitiveTaskInput::to_string

#ConfigCheckCoreOutput

#ConfigCheckCoreOutput::equal

#ConfigCheckCoreOutput::from_json

#ConfigCheckCoreOutput::not_equal

#ConfigCheckCoreOutput::output

#ConfigCheckCoreOutput::to_json

#ConfigCheckCoreOutput::to_repr

#ConfigCheckCoreOutput::to_string

#ConfigCheckIssueOutput

#ConfigCheckIssueOutput::equal

#ConfigCheckIssueOutput::from_json

#ConfigCheckIssueOutput::not_equal

#ConfigCheckIssueOutput::output

#ConfigCheckIssueOutput::to_json

#ConfigCheckIssueOutput::to_repr

#ConfigCheckIssueOutput::to_string

#ConfigCheckListedTestInput

#ConfigCheckListedTestInput::equal

#ConfigCheckListedTestInput::from_json

#ConfigCheckListedTestInput::not_equal

#ConfigCheckListedTestInput::output

#ConfigCheckListedTestInput::to_json

#ConfigCheckListedTestInput::to_repr

#ConfigCheckListedTestInput::to_string

AffectedDirectSelectionInput

AffectedDirectSelectionInput::equal

AffectedDirectSelectionInput::from_json

AffectedDirectSelectionInput::not_equal

AffectedDirectSelectionInput::output

AffectedDirectSelectionInput::to_json

AffectedDirectSelectionInput::to_repr

AffectedDirectSelectionInput::to_string

AffectedReportCoreOutput

AffectedReportCoreOutput::equal

AffectedReportCoreOutput::from_json

AffectedReportCoreOutput::not_equal

AffectedReportCoreOutput::output

AffectedReportCoreOutput::to_json

AffectedReportCoreOutput::to_repr

AffectedReportCoreOutput::to_string

AffectedReportInput

AffectedReportInput::equal

AffectedReportInput::from_json

AffectedReportInput::not_equal

AffectedReportInput::output

AffectedReportInput::to_json

AffectedReportInput::to_repr

AffectedReportInput::to_string

AffectedReportSummaryOutput

AffectedReportSummaryOutput::equal

AffectedReportSummaryOutput::from_json

AffectedReportSummaryOutput::not_equal

AffectedReportSummaryOutput::output

AffectedReportSummaryOutput::to_json

AffectedReportSummaryOutput::to_repr

AffectedReportSummaryOutput::to_string

AffectedSelectionOutput

AffectedSelectionOutput::equal

AffectedSelectionOutput::from_json

AffectedSelectionOutput::not_equal

AffectedSelectionOutput::output

AffectedSelectionOutput::to_json

AffectedSelectionOutput::to_repr

AffectedSelectionOutput::to_string

AffectedTargetInput

AffectedTargetInput::equal

AffectedTargetInput::from_json

AffectedTargetInput::not_equal

AffectedTargetInput::output

AffectedTargetInput::to_json

AffectedTargetInput::to_repr

AffectedTargetInput::to_string

AffectedTransitiveTaskInput

AffectedTransitiveTaskInput::equal

AffectedTransitiveTaskInput::from_json

AffectedTransitiveTaskInput::not_equal

AffectedTransitiveTaskInput::output

AffectedTransitiveTaskInput::to_json

AffectedTransitiveTaskInput::to_repr

AffectedTransitiveTaskInput::to_string

ConfigCheckCoreOutput

ConfigCheckCoreOutput::equal

ConfigCheckCoreOutput::from_json

ConfigCheckCoreOutput::not_equal

ConfigCheckCoreOutput::output

ConfigCheckCoreOutput::to_json

ConfigCheckCoreOutput::to_repr

ConfigCheckCoreOutput::to_string

ConfigCheckIssueOutput

ConfigCheckIssueOutput::equal

ConfigCheckIssueOutput::from_json

ConfigCheckIssueOutput::not_equal

ConfigCheckIssueOutput::output

ConfigCheckIssueOutput::to_json

ConfigCheckIssueOutput::to_repr

ConfigCheckIssueOutput::to_string

ConfigCheckListedTestInput

ConfigCheckListedTestInput::equal

ConfigCheckListedTestInput::from_json

ConfigCheckListedTestInput::not_equal

ConfigCheckListedTestInput::output

ConfigCheckListedTestInput::to_json

ConfigCheckListedTestInput::to_repr

ConfigCheckListedTestInput::to_string