runbios-sdk 0.2.1-dev.97 → 0.2.1-rc.118

package/dist/types.d.ts

@@ -8,13 +8,13 @@ export interface BiOSConfig {
     orgId?: string;
     /** Workspace ID. Optional when using API keys (resolved from the key). Can override for multi-workspace keys. */
     workspaceId?: string;
-    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api-dev.runbios.ai hostname. */
+    /** Base URL for the API. Falls back to the RUNBIOS_BASE_URL environment variable (legacy: BIOS_BASE_URL), then the canonical https://api-staging.runbios.ai hostname. */
     baseUrl?: string;
     /** Request timeout in milliseconds. Defaults to 30000. */
     timeout?: number;
     /** Default per-deployment inference key. Can be overridden per inference call. */
     inferenceKey?: string;
-    /** Inference base URL. Defaults to baseUrl, then https://api-dev.runbios.ai. */
+    /** Inference base URL. Defaults to baseUrl, then https://api-staging.runbios.ai. */
     inferenceBaseUrl?: string;
     /** End-to-end inference timeout in milliseconds. Defaults to 15 minutes. */
     inferenceTimeout?: number;
@@ -396,8 +396,9 @@ export interface DatasetPreview {
 }
 /** Parameters for importing a dataset from HuggingFace Hub. */
 export interface DatasetImportHFParams {
-    /** HuggingFace dataset repository ID (e.g. "databricks/dolly-15k"). */
+    /** HuggingFace dataset repository ID (e.g. "HuggingFaceH4/ultrachat_200k"). */
     repoId: string;
+    revision?: string;
     /** Display name for the imported dataset. */
     name?: string;
     /** Dataset subset/config to import. */
@@ -418,6 +419,7 @@ export interface DatasetImportHFParams {
 /** Parameters for registering a HuggingFace dataset without an integration. */
 export interface DatasetRegisterHFParams {
     repoId: string;
+    revision?: string;
     name?: string;
     workspaceId?: string;
     description?: string;
@@ -441,6 +443,7 @@ export interface DatasetHubSearchParams {
 export interface DatasetHubPreviewParams {
     /** HuggingFace dataset ID. */
     datasetId: string;
+    integrationId?: string;
     /** Split to preview. Defaults to "train". */
     split?: string;
     /** Subset/config name. */
@@ -565,8 +568,10 @@ export interface TrainingCreateParams {
     name?: string;
     /** Target workspace ID. */
     workspaceId?: string;
-    /** Number of training epochs. */
+    /** Number of training epochs. Governs the full run when maxSteps is omitted. */
     epochs?: number;
+    /** Optional hard step cap that overrides epochs. Omit for no cap and all configured epochs. */
+    maxSteps?: number;
     /** Training batch size per device. */
     batchSize?: number;
     /** Gradient accumulation steps. */
@@ -609,7 +614,7 @@ export interface TrainingCreateParams {
     integrationId?: string;
     /** Existing network volume to attach. */
     networkVolumeId?: string;
-    /** Cache the composed dataset for retry/resume. Defaults to true server-side. */
+    /** @deprecated No effect. Prepared data is transient; exact resume rebuilds it from pinned source metadata and verifies its checksum. */
     cacheDataset?: boolean;
     /** Legacy dataset ordering mode. Prefer mixing for weighted/phased plans. */
     datasetMixing?: 'shuffle' | 'sequential' | 'interleave' | 'random' | 'curriculum';
@@ -754,12 +759,37 @@ export interface TrainingListResponse {
     limit: number;
     offset: number;
 }
+export interface TrainingDeviceMetrics {
+    memory_used_mib: number | null;
+    memory_total_mib: number | null;
+    utilization_pct: number | null;
+    temperature_c: number | null;
+}
+export interface TrainingResourceMetrics {
+    scope: 'worker';
+    sampled_at: string | null;
+    received_at: string;
+    gpu_count: number | null;
+    gpu_memory_used_mib: number | null;
+    gpu_memory_total_mib: number | null;
+    gpu_utilization_pct: number | null;
+    gpu_temperature_c: number | null;
+    host_ram_used_gib: number | null;
+    host_ram_limit_gib: number | null;
+    host_ram_pct: number | null;
+    host_cpu_usage_pct: number | null;
+    host_cpu_limit_cores: number | null;
+    disk_used_gib: number | null;
+    disk_total_gib: number | null;
+    gpus: TrainingDeviceMetrics[];
+}
 /** Training metrics for a job. */
 export interface TrainingMetrics {
     metrics: MetricPoint[];
     training_method?: string | null;
     rlhf_type?: string | null;
     graph_configs: MetricGraphConfig[];
+    resource_metrics?: TrainingResourceMetrics | null;
     /** @deprecated Use metrics. Populated as a compatibility alias. */
     steps?: MetricPoint[];
 }
@@ -877,6 +907,8 @@ export interface TrainingPreflightDataset {
 export interface TrainingPreflightWarning {
     code: string;
     message: string;
+    /** Request field the warning is about (e.g. `per_device_train_batch_size`), when there is one. */
+    field?: string;
 }
 /** Side-effect-free validation/sizing result; this endpoint never creates or bills a job. */
 export interface TrainingPreflightResponse {
@@ -897,6 +929,131 @@ export interface TrainingPreflightResponse {
     queue_eligible: boolean;
     warnings: TrainingPreflightWarning[];
     checked_at: string;
+    /**
+     * The trainer image's own sizing verdict for the requested GPU shape:
+     * recommended microbatch/accumulation/learning rate, predicted peak memory,
+     * minimum GPU count, wall-clock estimate, and whether the per-device batch
+     * you asked for is predicted to fit. Absent when no advisor is deployed.
+     */
+    advisor?: TrainingAdvisorVerdict;
+}
+/** Parameters for `training.recommend()` (GET /api/training/recommend). */
+export interface TrainingRecommendParams {
+    model: string;
+    modelRevision?: string;
+    integrationId?: string;
+    gpuType: string;
+    gpuCount?: number;
+    adapter?: 'full' | 'lora' | 'qlora';
+    method?: 'sft' | 'cpt' | 'pt';
+    maxLength?: number;
+    epochs?: number;
+    maxSteps?: number;
+    /** Your own microbatch, to be judged against the model. */
+    perDeviceTrainBatchSize?: number;
+    gradientAccumulationSteps?: number;
+    /** Datasets the job will train on; their measured token statistics feed the sizing. */
+    datasetIds?: string[];
+    workspaceId?: string;
+}
+/** Basis of one recommended value: measured on hardware, derived through a stated model, or an argued default. */
+export type TrainingAdvisorBasis = 'measured' | 'derived' | 'judgement';
+export interface TrainingAdvisorJustification {
+    field: string;
+    value: string;
+    reason: string;
+    basis: TrainingAdvisorBasis;
+}
+export interface TrainingAdvisorRecommendation {
+    per_device_train_batch_size: number;
+    gradient_accumulation_steps: number;
+    global_batch_size: number;
+    activation_checkpoint: string;
+    compile: boolean;
+    learning_rate: number;
+    warmup_steps: number;
+    parallelism: {
+        dp_replicate: number;
+        dp_shard: number;
+        tp: number;
+        pp: number;
+        cp: number;
+        ep: number;
+    };
+    /** Predicted peak reserved GPU memory per device, GiB. */
+    predicted_peak_gb: number;
+    /** (median, worst) percent the prediction ran over measurement on the calibration rows. */
+    memory_band_percent: [number, number];
+    memory_class: string;
+    predicted_mfu: number;
+    supervised_tokens_per_step: number;
+    predicted_roughness: number;
+    tokens_per_second: number;
+    throughput_basis: 'measured' | 'derived';
+    wall_clock: {
+        steps_per_epoch: number;
+        total_steps: number;
+        training_hours: number;
+        startup_minutes_estimate: number;
+        basis: TrainingAdvisorBasis;
+    } | null;
+}
+export interface TrainingAdvisorUserShape {
+    per_device_train_batch_size: number;
+    fits: boolean;
+    largest_fitting_batch?: number;
+    predicted_peak_gb?: number;
+    reason?: string;
+    /** Same global batch, a microbatch that fits. Present only when `fits` is false. */
+    suggested?: {
+        per_device_train_batch_size: number;
+        gradient_accumulation_steps: number;
+        reason: string;
+    };
+}
+/**
+ * Verdict of the training advisor. `available: false` means no advisor is
+ * deployed or it did not answer; nothing else is populated then.
+ */
+export interface TrainingAdvisorVerdict {
+    available: boolean;
+    reason?: string;
+    fits?: boolean;
+    /** Smallest GPU count of this type the job fits on; null when none up to the per-job cap. */
+    min_gpu_count?: number | null;
+    gpu?: {
+        platform_type: string;
+        sized_as: string;
+        capacity_gb: number;
+        capacity_measured: boolean;
+    };
+    model?: {
+        params_total_b: number;
+        params_active_b: number;
+        is_moe: boolean;
+        is_vlm: boolean;
+        has_linear_attention: boolean;
+    };
+    dataset_measured?: boolean;
+    seq_len?: number;
+    gpu_count?: number;
+    recommended?: TrainingAdvisorRecommendation;
+    user_shape?: TrainingAdvisorUserShape;
+    justifications?: TrainingAdvisorJustification[];
+    warnings?: string[];
+    dataset_stats_used?: {
+        num_rows: number;
+        avg_tokens_per_sample?: number;
+        avg_supervised_tokens_per_sample?: number;
+        has_images: boolean;
+        estimated: boolean;
+    };
+    measured_history?: {
+        tokens_per_second: number;
+        memory_anchors: number;
+    };
+    model_id?: string;
+    model_revision?: string;
 }
 /** One method, algorithm, or adapter reported by the pinned training engine. */
 export interface TrainingCapabilityChoice {
@@ -916,6 +1073,8 @@ export interface TrainingConfigFieldCapability {
     label: string;
     type: 'integer' | 'number' | 'boolean' | 'string' | 'string_array' | 'string_or_string_array' | 'object';
     default: unknown;
+    default_by_adapter?: Record<string, number>;
+    requires_step_horizon?: boolean;
     enabled: boolean;
     disabled_reason?: string;
     aliases?: string[];
@@ -1817,7 +1976,7 @@ export interface ApiKey {
  * on purpose: a scope added to the catalog must not make an existing SDK build
  * reject a key it just read back from the API.
  */
-export type ApiKeyScope = 'models:read' | 'datasets:read' | 'datasets:write' | 'training:read' | 'training:write' | 'billing:read' | 'deployments:read' | 'deployments:write' | 'analytics:read' | 'integrations:read' | 'integrations:write' | 'skills:read' | 'skills:write' | 'serverless' | (string & {});
+export type ApiKeyScope = 'models:read' | 'datasets:read' | 'datasets:write' | 'training:read' | 'training:write' | 'billing:read' | 'deployments:read' | 'deployments:write' | 'analytics:read' | 'integrations:read' | 'integrations:write' | 'skills:read' | 'skills:write' | 'loop:read' | 'loop:write' | 'serverless' | (string & {});
 /** Result of introspecting an API key — shows what it can do. */
 export interface ApiKeyIntrospection {
     auth_type: 'api_key' | 'jwt';
@@ -1953,3 +2112,458 @@ export interface ChatCompletionUsage {
     total_tokens: number;
     prompt_tokens_details?: PromptTokensDetails;
 }
+/** What a training set is shaped for. The three need different things. */
+export type LoopMethod = 'sft' | 'dpo' | 'grpo' | 'kto';
+/** Who judged an answer. */
+export type LoopSource = 'human' | 'verifier' | 'judge' | 'behavioural';
+/** The judgement itself. */
+/**
+ * The judgement recorded on an answer.
+ *
+ * `accepted` / `rejected` are the thumbs (see `upvote` / `downvote`).
+ * `edited` says the model was WRONG and carries the better answer.
+ * `gold` records the reference answer for the question, making no claim about
+ * whether the model was right — which is why it is separate from `edited`.
+ */
+export type LoopVerdict = 'accepted' | 'rejected' | 'edited' | 'scored' | 'gold';
+/** A function an assistant turn asked to invoke. `arguments` is JSON-encoded. */
+export interface LoopToolCall {
+    id?: string;
+    type?: string;
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** One conversational turn, in the chat-completions shape. */
+export interface LoopMessage {
+    role: string;
+    content?: string;
+    tool_calls?: LoopToolCall[];
+    tool_call_id?: string;
+    name?: string;
+}
+export interface LoopCaptureParams {
+    /** The source being recorded. Must be enabled first, or nothing is stored. */
+    deployment_id: string;
+    model: string;
+    messages: LoopMessage[];
+    completion?: string;
+    /** What the answering turn invoked, if anything. */
+    tool_calls?: LoopToolCall[];
+    /** The tool schema the model was offered. Without it, tool training invents names. */
+    tools?: unknown;
+    model_version?: string;
+    /** Ties multi-turn work together. */
+    conversation_id?: string;
+    /** Your own idempotency handle. Replaying it returns the same trace. */
+    request_id?: string;
+    prompt_tokens?: number;
+    completion_tokens?: number;
+    latency_ms?: number;
+    metadata?: Record<string, unknown>;
+}
+export interface LoopCaptureResult {
+    captured: boolean;
+    /** Present when captured. Ours, never the id you sent. */
+    trace_id?: string;
+    /** Set when something was removed before the record was written. */
+    redacted?: boolean;
+    download_url?: string;
+    /** Why nothing was stored, e.g. `capture_disabled`, `not_sampled`. */
+    reason?: string;
+}
+export interface LoopImportParams {
+    /**
+     * Where this came from. Required, and becomes the id every imported
+     * conversation is filed under, so the import stays sliceable later.
+     */
+    source: string;
+    /** The file, already parsed. At most 5000 rows per call. */
+    rows: Record<string, unknown>[];
+    /** Which model produced these, when the rows do not say per-row. */
+    model?: string;
+    /** Applied to every row: importing a dump is when somebody knows what it is. */
+    labels?: string[];
+    attributes?: Record<string, string>;
+}
+export interface LoopImportResult {
+    imported: number;
+    /**
+     * How many arrived carrying a verdict. Reported apart from `imported`
+     * because it is the difference between data you can train on and data
+     * somebody still has to look at.
+     */
+    reviewed: number;
+    needs_review: number;
+    refused: number;
+    /** How many rows of each recognised shape, so a mis-shaped file is visible. */
+    by_shape: Record<string, number>;
+    refused_why: Record<string, number>;
+    notes: string[];
+}
+export interface LoopSignal {
+    id: string;
+    trace_id: string;
+    source: LoopSource;
+    verdict: LoopVerdict;
+    correction: string | null;
+    score: number | null;
+    ground_truth: string | null;
+    reason: string | null;
+    author: string | null;
+    created_at: string;
+}
+export interface LoopSignalParams {
+    verdict: LoopVerdict;
+    source?: LoopSource;
+    /** Required when verdict is `edited`. The answer the model should have given. */
+    correction?: string;
+    /** Required when verdict is `scored`. */
+    score?: number;
+    /** A value or fact the answer can be checked against. GRPO needs one. */
+    ground_truth?: string;
+    reason?: string;
+    author?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LoopTrace {
+    id: string;
+    workspace_id: string;
+    deployment_id: string | null;
+    model: string;
+    model_version: string | null;
+    messages: LoopMessage[];
+    completion: string;
+    tool_calls?: LoopToolCall[];
+    tools?: unknown;
+    conversation_id: string | null;
+    request_id: string | null;
+    prompt_tokens: number | null;
+    completion_tokens: number | null;
+    latency_ms: number | null;
+    redacted_at: string | null;
+    /** What the redaction pass removed, counted by rule. */
+    redaction_report?: Record<string, number>;
+    created_at: string;
+    expires_at: string;
+    signals?: LoopSignal[];
+}
+export interface LoopTraceListParams {
+    deployment_id?: string;
+    conversation_id?: string;
+    from?: string;
+    to?: string;
+    /** Only conversations that already carry a verdict. */
+    signalled?: boolean;
+    /** One bare tag. A tag with children matches them too. */
+    label?: string;
+    /**
+     * Named dimensions, ANDed together: `{ category: 'billing', language: 'es' }`.
+     * Exact within their key — `source=support` does not match `team=support`.
+     */
+    attributes?: Record<string, string>;
+    /** Only the conversations nobody has described yet. */
+    unlabelled?: boolean;
+    limit?: number;
+    offset?: number;
+}
+export interface LoopTraceListResponse {
+    traces: LoopTrace[];
+    total: number;
+    limit: number;
+    offset: number;
+}
+export interface LoopDatasetCreateParams {
+    name: string;
+    method: LoopMethod;
+    deployment_id?: string;
+    from?: string;
+    to?: string;
+    /** Narrow to one slice. A label with children selects them too. */
+    label?: string;
+    /** Take this many at random from what the filters matched. */
+    sample?: number;
+    /** Holds back your most recent work, not a random slice. 0-50. */
+    holdout_percent?: number;
+    max_items?: number;
+    /**
+     * Named dimensions, ANDed with each other and with `label`:
+     * `{ category: 'billing', language: 'es' }`. This is what turns one captured
+     * corpus into a different dataset for every task somebody trains for.
+     */
+    attributes?: Record<string, string>;
+    /** Only the conversations nobody has described yet. */
+    unlabelled?: boolean;
+}
+export interface LoopDataset {
+    id: string;
+    workspace_id: string;
+    name: string;
+    method: LoopMethod;
+    status: string;
+    spec: Record<string, unknown>;
+    item_count: number;
+    considered_count: number;
+    /** Why rows were left out, by reason. */
+    rejected_counts: Record<string, number>;
+    holdout_count: number;
+    holdout_cutoff: string | null;
+    created_by: string | null;
+    created_at: string;
+    completed_at: string | null;
+    download_url: string;
+}
+export interface LoopDatasetListParams {
+    method?: LoopMethod;
+    limit?: number;
+    offset?: number;
+}
+export interface LoopDatasetItem {
+    id: number;
+    trace_id: string;
+    split: 'train' | 'holdout';
+    payload: Record<string, unknown>;
+    dedup_key: string;
+    created_at: string;
+    /** The conversation this row was built from. */
+    trace_url: string;
+}
+export interface LoopConfig {
+    deployment_id: string;
+    workspace_id: string;
+    enabled: boolean;
+    retention_days: number;
+    sample_rate: number;
+    enabled_by: string | null;
+    enabled_at: string | null;
+    updated_at: string;
+}
+export interface LoopConfigParams {
+    enabled: boolean;
+    retention_days?: number;
+    /** Deterministic per conversation, so turns are never split. 0 < rate <= 1. */
+    sample_rate?: number;
+}
+/** One thing a judge scores, separately from the others. */
+export interface LoopJudgeDimension {
+    key: string;
+    description?: string;
+}
+/** Which slice of the corpus a judge is responsible for. */
+export interface LoopJudgeSelection {
+    label?: string;
+    deployment_id?: string;
+    from?: string;
+    to?: string;
+    sample?: number;
+    /** Skip conversations that already carry a judge verdict. */
+    only_unscored?: boolean;
+}
+export interface LoopJudge {
+    id: string;
+    workspace_id: string;
+    name: string;
+    instructions: string;
+    dimensions: LoopJudgeDimension[];
+    selection: LoopJudgeSelection;
+    model: string | null;
+    write_gold: boolean;
+    enabled: boolean;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface LoopJudgeParams {
+    name: string;
+    instructions: string;
+    dimensions: LoopJudgeDimension[];
+    selection?: LoopJudgeSelection;
+    model?: string;
+    /**
+     * Let this judge write the answer that should have been given, not just a
+     * score. Off by default: a reference answer written by a model and then
+     * trained on is distillation, which is a decision you make deliberately.
+     */
+    write_gold?: boolean;
+    enabled?: boolean;
+}
+/** One pass of one rubric over one slice. */
+export interface LoopJudgeRun {
+    id: string;
+    judge_id: string;
+    judge_name?: string;
+    status: 'open' | 'done';
+    instructions: string;
+    dimensions: LoopJudgeDimension[];
+    model: string | null;
+    selected: number;
+    scored: number;
+    failed: number;
+    created_by: string | null;
+    created_at: string;
+    finished_at: string | null;
+}
+/**
+ * One conversation to score, already rendered into the prompt to send.
+ *
+ * Send `prompt` as-is. Assembling it yourself is how two callers end up giving
+ * the same rubric different instructions, and two judges given different
+ * instructions are not one judge.
+ */
+export interface LoopJudgeWorkItem {
+    trace_id: string;
+    messages: Array<{
+        role: string;
+        content?: string;
+    }>;
+    answer: string;
+    prompt: string;
+}
+export interface LoopJudgeWork {
+    run: LoopJudgeRun;
+    items: LoopJudgeWorkItem[];
+    remaining: number;
+}
+/** One scored conversation going back. */
+export interface LoopJudgeVerdict {
+    trace_id: string;
+    /** One score per dimension the rubric asked for, each between 0 and 1. */
+    scores?: Record<string, number>;
+    /** Your own combination of them. Left out, the plain mean is used. */
+    overall?: number;
+    reason?: string;
+    /** Only stored if the judge was created with `write_gold`. */
+    gold?: string;
+    /** Mark an item you could not score, instead of dropping it silently. */
+    error?: string;
+}
+export interface LoopJudgeVerdictResult {
+    run: LoopJudgeRun;
+    recorded: number;
+    failed: number;
+    rejected: Array<{
+        trace_id: string;
+        error: string;
+    }>;
+}
+export interface LoopStats {
+    traces: number;
+    signalled_traces: number;
+    signals: number;
+    by_verdict: Record<string, number>;
+    by_source: Record<string, number>;
+    datasets: number;
+    /** Upper bounds: deduplication runs when a set is built. */
+    ready: Record<LoopMethod, number>;
+}
+export interface LoopCandidateParams {
+    completion?: string;
+    /** An alternative that is itself a tool call. */
+    tool_calls?: LoopToolCall[];
+    /** Which model produced this alternative. The teacher, when distilling. */
+    model?: string;
+    model_version?: string;
+    /** Unscored alternatives cannot pair -- a missing score is not a low one. */
+    score?: number;
+    /** Required alongside a score: human | verifier | judge | behavioural. */
+    score_source?: LoopSource;
+    reason?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface LoopCandidate {
+    id: string;
+    trace_id: string;
+    model: string | null;
+    model_version: string | null;
+    completion: string;
+    tool_calls?: LoopToolCall[];
+    score: number | null;
+    score_source: LoopSource | null;
+    reason: string | null;
+    metadata: Record<string, unknown>;
+    created_at: string;
+}
+/** The deterministic checks a grader can perform. */
+export type LoopGraderKind = 'exact_match' | 'contains' | 'regex' | 'json_valid' | 'numeric' | 'tool_called';
+export interface LoopGraderConfig {
+    expected?: string;
+    /** Every phrase that must appear. */
+    required?: string[];
+    /** Phrases that must not. On their own these are passed by silence. */
+    forbidden?: string[];
+    pattern?: string;
+    /** Keys the answer must carry, for `json_valid`. */
+    keys?: string[];
+    /** How far from `expected` still counts, for `numeric`. */
+    tolerance?: number;
+    /** The function that must have been called, for `tool_called`. */
+    function?: string;
+    case_sensitive?: boolean;
+}
+export interface LoopGraderParams {
+    name: string;
+    kind: LoopGraderKind;
+    config: LoopGraderConfig;
+    /** The multiplier. Twice as important, twice the weight. Must exceed zero. */
+    weight?: number;
+    enabled?: boolean;
+    /** Limit the rule to one capture source. Omit to apply it everywhere. */
+    deployment_id?: string;
+    /**
+     * Aim the rule at one slice of the corpus. A master group covers its
+     * children. Outside that slice the rule is NOT APPLIED, rather than failed,
+     * so it stays out of the score entirely. Omit to apply it everywhere.
+     */
+    label?: string;
+}
+export interface LoopGrader extends LoopGraderParams {
+    id: string;
+    workspace_id: string;
+    weight: number;
+    enabled: boolean;
+    created_by: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface LoopGraderResult {
+    grader_id: string;
+    name: string;
+    kind: string;
+    weight: number;
+    passed: boolean;
+    score: number;
+    /** What happened, in words -- "failed" alone sends you to read the rule. */
+    detail: string;
+    /** The rule had no opinion. Excluded from the score rather than counted 0. */
+    skipped: boolean;
+}
+export interface LoopGradeReport {
+    /** Weighted mean over the rules that applied, 0 to 1. */
+    score: number;
+    results: LoopGraderResult[];
+    /** The denominator. 1.0 from one rule is not 1.0 from six. */
+    applied: number;
+    skipped: number;
+}
+export interface LoopGradeResult {
+    report: LoopGradeReport;
+    /** Null when no rule applied, because no verdict was invented. */
+    signal_id: string | null;
+    candidates_graded: number;
+}
+export interface LoopLabel {
+    label: string;
+    /** The master group this label belongs to, if any. */
+    parent: string | null;
+    created_by: string | null;
+    created_at: string;
+    /** The dimension this value belongs to. `tag` for a bare name. */
+    key: string;
+}
+export interface LoopLabelCount {
+    label: string;
+    parent: string | null;
+    traces: number;
+    key: string;
+}