modaic 0.1.0

package/src/sdk/sdk.ts

@@ -0,0 +1,750 @@
+/*
+ * Code generated by Speakeasy (https://speakeasy.com). DO NOT EDIT.
+ */
+
+import { cancelBatchPredictionsJobApiV1JobsBatchPredictionsJobIdDelete } from "../funcs/cancel-batch-predictions-job-api-v1-jobs-batch-predictions-job-id-delete.js";
+import { cancelConfidenceScoreJobApiV1JobsConfidenceScoresJobIdDelete } from "../funcs/cancel-confidence-score-job-api-v1-jobs-confidence-scores-job-id-delete.js";
+import { cancelOptimizationJobApiV1JobsGepaJobIdDelete } from "../funcs/cancel-optimization-job-api-v1-jobs-gepa-job-id-delete.js";
+import { createChatCompletionApiV1ArbitersChatCompletionsPost } from "../funcs/create-chat-completion-api-v1-arbiters-chat-completions-post.js";
+import { createChatCompletionApiV1ChatCompletionsPost } from "../funcs/create-chat-completion-api-v1-chat-completions-post.js";
+import { createPredictionApiV1ArbitersPredictionsPost } from "../funcs/create-prediction-api-v1-arbiters-predictions-post.js";
+import { createPredictionApiV2ArbitersPredictionsPost } from "../funcs/create-prediction-api-v2-arbiters-predictions-post.js";
+import { deleteExamplesApiV1ExamplesDelete } from "../funcs/delete-examples-api-v1-examples-delete.js";
+import { dispatchPredictionApiV1ArbitersPredictionsDispatchPost } from "../funcs/dispatch-prediction-api-v1-arbiters-predictions-dispatch-post.js";
+import { downloadExportApiV1ExamplesExportDownloadGet } from "../funcs/download-export-api-v1-examples-export-download-get.js";
+import { enqueuePredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidencePost } from "../funcs/enqueue-prediction-confidence-api-v1-arbiters-predictions-prediction-id-confidence-post.js";
+import { exportExamplesApiV1ExamplesExportPost } from "../funcs/export-examples-api-v1-examples-export-post.js";
+import { getArbiterApiV1ArbitersGet } from "../funcs/get-arbiter-api-v1-arbiters-get.js";
+import { getArbiterSchemaOutputApiV1ArbitersSchemaGet } from "../funcs/get-arbiter-schema-output-api-v1-arbiters-schema-get.js";
+import { getBatchPredictionsJobStatusApiV1JobsBatchPredictionsJobIdGet } from "../funcs/get-batch-predictions-job-status-api-v1-jobs-batch-predictions-job-id-get.js";
+import { getConfidenceScoreJobStatusApiV1JobsConfidenceScoresJobIdGet } from "../funcs/get-confidence-score-job-status-api-v1-jobs-confidence-scores-job-id-get.js";
+import { getDistinctHashesApiV1ExamplesDistinctHashesGet } from "../funcs/get-distinct-hashes-api-v1-examples-distinct-hashes-get.js";
+import { getExampleByIdApiV1ExamplesExampleIdGet } from "../funcs/get-example-by-id-api-v1-examples-example-id-get.js";
+import { getGradedCountApiV1ExamplesGradedCountGet } from "../funcs/get-graded-count-api-v1-examples-graded-count-get.js";
+import { getOptimizationJobLogsApiV1JobsGepaJobIdLogsGet } from "../funcs/get-optimization-job-logs-api-v1-jobs-gepa-job-id-logs-get.js";
+import { getOptimizationJobStatusApiV1JobsGepaJobIdGet } from "../funcs/get-optimization-job-status-api-v1-jobs-gepa-job-id-get.js";
+import { getPredictionConfidenceApiV1ArbitersPredictionsConfidencePost } from "../funcs/get-prediction-confidence-api-v1-arbiters-predictions-confidence-post.js";
+import { getPredictionConfidenceStatusApiV1ArbitersPredictionsPredictionIdConfidenceGet } from "../funcs/get-prediction-confidence-status-api-v1-arbiters-predictions-prediction-id-confidence-get.js";
+import { getSupportedModelsApiV1ArbitersSupportedModelsGet } from "../funcs/get-supported-models-api-v1-arbiters-supported-models-get.js";
+import { hasUncalibratedPredictionsApiV1ExamplesHasUncalibratedGet } from "../funcs/has-uncalibrated-predictions-api-v1-examples-has-uncalibrated-get.js";
+import { ingestExamplesApiV1ExamplesPost } from "../funcs/ingest-examples-api-v1-examples-post.js";
+import { initArbiterApiV1ArbitersPost } from "../funcs/init-arbiter-api-v1-arbiters-post.js";
+import { listExamplesApiV1ExamplesGet } from "../funcs/list-examples-api-v1-examples-get.js";
+import { patchExampleApiV1ExamplesExampleIdAnnotationPatch } from "../funcs/patch-example-api-v1-examples-example-id-annotation-patch.js";
+import { startBatchPredictionsJobApiV1JobsBatchPredictionsPost } from "../funcs/start-batch-predictions-job-api-v1-jobs-batch-predictions-post.js";
+import { startConfidenceScoreJobApiV1JobsConfidenceScoresPost } from "../funcs/start-confidence-score-job-api-v1-jobs-confidence-scores-post.js";
+import { startOptimizationJobApiV1JobsGepaPost } from "../funcs/start-optimization-job-api-v1-jobs-gepa-post.js";
+import { streamBatchPredictionsEventsApiV1JobsBatchPredictionsJobIdEventsGet } from "../funcs/stream-batch-predictions-events-api-v1-jobs-batch-predictions-job-id-events-get.js";
+import { streamBatchPredictionsResultsApiV1JobsBatchPredictionsJobIdResultsGet } from "../funcs/stream-batch-predictions-results-api-v1-jobs-batch-predictions-job-id-results-get.js";
+import {
+  streamPredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidenceStreamGet,
+} from "../funcs/stream-prediction-confidence-api-v1-arbiters-predictions-prediction-id-confidence-stream-get.js";
+import { updateArbiterMetadataApiV1ArbitersMetadataPatch } from "../funcs/update-arbiter-metadata-api-v1-arbiters-metadata-patch.js";
+import { ClientSDK, RequestOptions } from "../lib/sdks.js";
+import * as models from "../models/index.js";
+import * as operations from "../models/operations/index.js";
+import { unwrapAsync } from "../types/fp.js";
+
+export class ModaicClient extends ClientSDK {
+  /**
+   * Create Chat Completion
+   */
+  async createChatCompletionApiV1ChatCompletionsPost(
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(createChatCompletionApiV1ChatCompletionsPost(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Start Confidence Score Job
+   *
+   * @remarks
+   * Start an async job to compute confidence scores for all predictions
+   * with null confidence for the given repo.
+   */
+  async startConfidenceScoreJobApiV1JobsConfidenceScoresPost(
+    request: models.ConfidenceScoreJobRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(startConfidenceScoreJobApiV1JobsConfidenceScoresPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Confidence Score Job Status
+   *
+   * @remarks
+   * Get the status of a confidence score computation job.
+   */
+  async getConfidenceScoreJobStatusApiV1JobsConfidenceScoresJobIdGet(
+    request:
+      operations.GetConfidenceScoreJobStatusApiV1JobsConfidenceScoresJobIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      getConfidenceScoreJobStatusApiV1JobsConfidenceScoresJobIdGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Cancel Confidence Score Job
+   *
+   * @remarks
+   * Cancel a running confidence score computation job.
+   */
+  async cancelConfidenceScoreJobApiV1JobsConfidenceScoresJobIdDelete(
+    request:
+      operations.CancelConfidenceScoreJobApiV1JobsConfidenceScoresJobIdDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      cancelConfidenceScoreJobApiV1JobsConfidenceScoresJobIdDelete(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Start Optimization Job
+   *
+   * @remarks
+   * Start an async job to run GEPA optimization on an arbiter.
+   * Uses annotated train/test predictions from ClickHouse to optimize the arbiter.
+   * Runs in an isolated Modal Sandbox for clean cancellation support.
+   *
+   * The hub_jobs row is created *before* the sandbox starts so that the
+   * sandbox always has a row to update with logs and terminal state.
+   */
+  async startOptimizationJobApiV1JobsGepaPost(
+    request: models.GepaJobRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(startOptimizationJobApiV1JobsGepaPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Cancel Optimization Job
+   *
+   * @remarks
+   * Cancel a running GEPA optimization job.
+   *
+   * Only cancels if the job is still in the ``optimizing`` phase.  If the
+   * sandbox already reached a terminal state (``finalizing`` or ``done``),
+   * the UPDATE is a no-op so we don't clobber a successful result or
+   * interfere with the finalization pipeline.
+   */
+  async cancelOptimizationJobApiV1JobsGepaJobIdDelete(
+    request: operations.CancelOptimizationJobApiV1JobsGepaJobIdDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(cancelOptimizationJobApiV1JobsGepaJobIdDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Optimization Job Status
+   *
+   * @remarks
+   * Get the status of a GEPA optimization job.
+   *
+   * This endpoint is a pure Postgres reader. The sandbox writes logs and
+   * terminal state directly to the hub_jobs row; a background Celery task
+   * handles finalization (env_var cleanup, Slack notification, re-predict
+   * trigger). Subsequent re-predict/scoring phases are tracked via the
+   * ``phase`` column updated by the Celery pipeline.
+   */
+  async getOptimizationJobStatusApiV1JobsGepaJobIdGet(
+    request: operations.GetOptimizationJobStatusApiV1JobsGepaJobIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<models.GepaJobResponse> {
+    return unwrapAsync(getOptimizationJobStatusApiV1JobsGepaJobIdGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Optimization Job Logs
+   *
+   * @remarks
+   * Get logs from a GEPA optimization job.
+   *
+   * Logs are written directly to Postgres by the sandbox — this endpoint
+   * is a pure reader.
+   */
+  async getOptimizationJobLogsApiV1JobsGepaJobIdLogsGet(
+    request: operations.GetOptimizationJobLogsApiV1JobsGepaJobIdLogsGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(getOptimizationJobLogsApiV1JobsGepaJobIdLogsGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Start Batch Predictions Job
+   *
+   * @remarks
+   * Start an async batch prediction job.
+   *
+   * Two input modes (mutually exclusive):
+   *
+   * * ``examples`` — ingest brand-new examples and run predictions on them.
+   * * ``example_ids`` — re-predict existing examples (referenced by their
+   *   ClickHouse ids). Predictions are inserted as new versions on the
+   *   existing example rows; no new examples rows are written.
+   *
+   * When ``compute_confidence=True`` the worker pre-warms a probe scorer
+   * container per arbiter and, after predictions persist, kicks off Modal
+   * batch confidence scoring filtered to the prediction_ids produced by
+   * this job (so we don't accidentally re-score unrelated NULL-confidence
+   * rows). Predictions are visible to clients during the scoring phase via
+   * ``GET /results`` — confidence populates as Modal streams.
+   *
+   * Phases visible via ``GET /{job_id}`` and SSE: ``predicting → scoring →
+   * done`` (or ``failed``).
+   */
+  async startBatchPredictionsJobApiV1JobsBatchPredictionsPost(
+    request: models.BatchPredictionsJobRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(startBatchPredictionsJobApiV1JobsBatchPredictionsPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Batch Predictions Job Status
+   *
+   * @remarks
+   * Get the latest snapshot for a batch predictions job.
+   *
+   * Returns the same `BatchPredictionsEvent` shape SSE forwards (minus the
+   * per-prediction payload). For the per-prediction list, use `GET /results`.
+   *
+   * Mapping:
+   *   * Celery PROGRESS  → return the latest snapshot stored in `meta`.
+   *   * Celery PENDING   → synthesize a zeroed `event="start"` snapshot.
+   *   * Celery SUCCESS   → return the terminal `event="finish"` snapshot.
+   *   * Celery FAILURE   → synthesize an `event="finish", status="failed"` dict.
+   *   * Celery REVOKED   → synthesize an `event="finish", status="failed",
+   *     error="cancelled"` dict.
+   */
+  async getBatchPredictionsJobStatusApiV1JobsBatchPredictionsJobIdGet(
+    request:
+      operations.GetBatchPredictionsJobStatusApiV1JobsBatchPredictionsJobIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      getBatchPredictionsJobStatusApiV1JobsBatchPredictionsJobIdGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Cancel Batch Predictions Job
+   *
+   * @remarks
+   * Cancel a running batch predictions job. Because all inserts happen in a
+   * single transaction at the end of the task, cancelling mid-execution leaves
+   * no partial state in ClickHouse.
+   */
+  async cancelBatchPredictionsJobApiV1JobsBatchPredictionsJobIdDelete(
+    request:
+      operations.CancelBatchPredictionsJobApiV1JobsBatchPredictionsJobIdDeleteRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      cancelBatchPredictionsJobApiV1JobsBatchPredictionsJobIdDelete(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Stream Batch Predictions Events
+   *
+   * @remarks
+   * Stream batch-job progress snapshots as SSE.
+   *
+   * Each frame is a `BatchPredictionsEvent`-shaped JSON payload (with the
+   * per-prediction field stripped server-side; clients fetch the canonical
+   * list via `GET /results`). Frames carry both the SSE `id:` (Redis stream
+   * msg id) and `event:` (the snapshot's `event` field — `start`,
+   * `prediction`, `score`, `finish`).
+   *
+   * Resumption: clients automatically send `Last-Event-ID` on reconnect;
+   * we use it as the `XREAD` start id so no events are missed (provided
+   * the stream hasn't been trimmed past it).
+   *
+   * Heartbeats every ~15s keep proxies from idling the connection out.
+   * Synthetic terminal: if Celery reaches a terminal state without a
+   * `finish` snapshot reaching Redis, emit one so clients don't hang.
+   */
+  async streamBatchPredictionsEventsApiV1JobsBatchPredictionsJobIdEventsGet(
+    request:
+      operations.StreamBatchPredictionsEventsApiV1JobsBatchPredictionsJobIdEventsGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      streamBatchPredictionsEventsApiV1JobsBatchPredictionsJobIdEventsGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Stream Batch Predictions Results
+   *
+   * @remarks
+   * Stream results for a batch predictions job as application/x-ndjson.
+   */
+  async streamBatchPredictionsResultsApiV1JobsBatchPredictionsJobIdResultsGet(
+    request:
+      operations.StreamBatchPredictionsResultsApiV1JobsBatchPredictionsJobIdResultsGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      streamBatchPredictionsResultsApiV1JobsBatchPredictionsJobIdResultsGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Get Arbiter
+   */
+  async getArbiterApiV1ArbitersGet(
+    request: operations.GetArbiterApiV1ArbitersGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(getArbiterApiV1ArbitersGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Arbiter Schema Output
+   */
+  async getArbiterSchemaOutputApiV1ArbitersSchemaGet(
+    request: operations.GetArbiterSchemaOutputApiV1ArbitersSchemaGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(getArbiterSchemaOutputApiV1ArbitersSchemaGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create Prediction
+   */
+  async createPredictionApiV1ArbitersPredictionsPost(
+    request: models.SrcApiV1ArbitersSchemasPredictExampleRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(createPredictionApiV1ArbitersPredictionsPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Prediction Confidence
+   *
+   * @remarks
+   * Synchronous online confidence scoring keyed by request body.
+   *
+   * Lets a caller score a fresh ``messages`` payload against an arbiter
+   * without first persisting a prediction. If ``prediction_id`` is provided,
+   * the server also writes a versioned ``predictions`` row in-process with
+   * the new embedding + confidence (Modal returns the embedding; head +
+   * calibrator + CH insert happen server-side). Returns the score as a float.
+   */
+  async getPredictionConfidenceApiV1ArbitersPredictionsConfidencePost(
+    request: models.GetConfidenceRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      getPredictionConfidenceApiV1ArbitersPredictionsConfidencePost(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Enqueue Prediction Confidence
+   *
+   * @remarks
+   * Idempotent: ensure a confidence score exists for ``prediction_id``.
+   *
+   * - 404 if the prediction is unknown to both Redis and ClickHouse.
+   * - 200 ``completed`` if ClickHouse already has a confidence value.
+   * - 202 ``queued`` otherwise (newly enqueued or already in flight).
+   */
+  async enqueuePredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidencePost(
+    request:
+      operations.EnqueuePredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidencePostRequest,
+    options?: RequestOptions,
+  ): Promise<models.ConfidenceStatusResponse> {
+    return unwrapAsync(
+      enqueuePredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidencePost(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Get Prediction Confidence Status
+   *
+   * @remarks
+   * Read current state of the confidence resource for ``prediction_id``.
+   *
+   * Returns 404 when no one has POSTed and no row exists. Otherwise returns
+   * 200 with status ``completed`` / ``queued`` / ``failed``.
+   */
+  async getPredictionConfidenceStatusApiV1ArbitersPredictionsPredictionIdConfidenceGet(
+    request:
+      operations.GetPredictionConfidenceStatusApiV1ArbitersPredictionsPredictionIdConfidenceGetRequest,
+    options?: RequestOptions,
+  ): Promise<models.ConfidenceStatusResponse> {
+    return unwrapAsync(
+      getPredictionConfidenceStatusApiV1ArbitersPredictionsPredictionIdConfidenceGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Stream Prediction Confidence
+   *
+   * @remarks
+   * Stream the confidence result for ``prediction_id`` over SSE.
+   *
+   * Emits a ``status`` event on subscribe (``queued`` or ``completed``) and a
+   * terminal ``completed`` / ``failed`` event when the worker finishes. Sends
+   * a comment line every ``STREAM_KEEPALIVE_INTERVAL_S`` seconds so idle
+   * proxies don't drop the connection. Closes after ``STREAM_WALL_CAP_S``
+   * seconds with a final ``status: queued`` event so the client reconnects
+   * instead of holding open forever.
+   *
+   * Returns 404 if neither a CH row, a pending Redis prediction, nor a
+   * Celery task exists for ``prediction_id``. Returns 403 if the caller
+   * lacks read access on the arbiter repo.
+   */
+  async streamPredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidenceStreamGet(
+    request:
+      operations.StreamPredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidenceStreamGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(
+      streamPredictionConfidenceApiV1ArbitersPredictionsPredictionIdConfidenceStreamGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Dispatch Prediction
+   */
+  async dispatchPredictionApiV1ArbitersPredictionsDispatchPost(
+    request: models.DispatchPredictionRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(dispatchPredictionApiV1ArbitersPredictionsDispatchPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create Chat Completion
+   */
+  async createChatCompletionApiV1ArbitersChatCompletionsPost(
+    request: models.ChatCompletionRequest,
+    options?: RequestOptions,
+  ): Promise<models.ChatCompletionResponse> {
+    return unwrapAsync(createChatCompletionApiV1ArbitersChatCompletionsPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Supported Models
+   */
+  async getSupportedModelsApiV1ArbitersSupportedModelsGet(
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(getSupportedModelsApiV1ArbitersSupportedModelsGet(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * Init Arbiter
+   */
+  async initArbiterApiV1ArbitersPost(
+    request: models.InitArbiterRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(initArbiterApiV1ArbitersPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Update Arbiter Metadata
+   *
+   * @remarks
+   * Patch YAML frontmatter metadata in the arbiter's README.md.
+   */
+  async updateArbiterMetadataApiV1ArbitersMetadataPatch(
+    request: models.UpdateArbiterMetadataRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(updateArbiterMetadataApiV1ArbitersMetadataPatch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Ingest Examples
+   */
+  async ingestExamplesApiV1ExamplesPost(
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(ingestExamplesApiV1ExamplesPost(
+      this,
+      options,
+    ));
+  }
+
+  /**
+   * List Examples
+   *
+   * @remarks
+   * Offset-based pagination for examples within a single repo, ordered by (created_at, id) ascending.
+   */
+  async listExamplesApiV1ExamplesGet(
+    request: operations.ListExamplesApiV1ExamplesGetRequest,
+    options?: RequestOptions,
+  ): Promise<models.PaginatedPage> {
+    return unwrapAsync(listExamplesApiV1ExamplesGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Delete Examples
+   *
+   * @remarks
+   * Delete one or more examples from a repo.
+   */
+  async deleteExamplesApiV1ExamplesDelete(
+    request: models.DeleteExamplesRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(deleteExamplesApiV1ExamplesDelete(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Export Examples
+   *
+   * @remarks
+   * Export a repo's latest prediction state as parquet and return a signed URL.
+   */
+  async exportExamplesApiV1ExamplesExportPost(
+    request: models.ExportExamplesRequest,
+    options?: RequestOptions,
+  ): Promise<models.ExportExamplesResponse> {
+    return unwrapAsync(exportExamplesApiV1ExamplesExportPost(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Download Export
+   *
+   * @remarks
+   * Stream an exported parquet file from S3.
+   */
+  async downloadExportApiV1ExamplesExportDownloadGet(
+    request: operations.DownloadExportApiV1ExamplesExportDownloadGetRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(downloadExportApiV1ExamplesExportDownloadGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Distinct Hashes
+   *
+   * @remarks
+   * Return distinct arbiter_hash values for the repo's latest predictions.
+   */
+  async getDistinctHashesApiV1ExamplesDistinctHashesGet(
+    request: operations.GetDistinctHashesApiV1ExamplesDistinctHashesGetRequest,
+    options?: RequestOptions,
+  ): Promise<Array<string>> {
+    return unwrapAsync(getDistinctHashesApiV1ExamplesDistinctHashesGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Has Uncalibrated Predictions
+   *
+   * @remarks
+   * Check whether there are predictions without confidence scores.
+   */
+  async hasUncalibratedPredictionsApiV1ExamplesHasUncalibratedGet(
+    request:
+      operations.HasUncalibratedPredictionsApiV1ExamplesHasUncalibratedGetRequest,
+    options?: RequestOptions,
+  ): Promise<{ [k: string]: any }> {
+    return unwrapAsync(
+      hasUncalibratedPredictionsApiV1ExamplesHasUncalibratedGet(
+        this,
+        request,
+        options,
+      ),
+    );
+  }
+
+  /**
+   * Get Graded Count
+   *
+   * @remarks
+   * Count predictions that have been graded (have ground truth).
+   */
+  async getGradedCountApiV1ExamplesGradedCountGet(
+    request: operations.GetGradedCountApiV1ExamplesGradedCountGetRequest,
+    options?: RequestOptions,
+  ): Promise<{ [k: string]: any }> {
+    return unwrapAsync(getGradedCountApiV1ExamplesGradedCountGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Patch Example
+   *
+   * @remarks
+   * Updates an example annotation.
+   */
+  async patchExampleApiV1ExamplesExampleIdAnnotationPatch(
+    request:
+      operations.PatchExampleApiV1ExamplesExampleIdAnnotationPatchRequest,
+    options?: RequestOptions,
+  ): Promise<any> {
+    return unwrapAsync(patchExampleApiV1ExamplesExampleIdAnnotationPatch(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Get Example By Id
+   */
+  async getExampleByIdApiV1ExamplesExampleIdGet(
+    request: operations.GetExampleByIdApiV1ExamplesExampleIdGetRequest,
+    options?: RequestOptions,
+  ): Promise<models.PredictedExample> {
+    return unwrapAsync(getExampleByIdApiV1ExamplesExampleIdGet(
+      this,
+      request,
+      options,
+    ));
+  }
+
+  /**
+   * Create Prediction
+   *
+   * @remarks
+   * Run a single arbiter against a single example and return a flat result.
+   *
+   * Unlike v1's ``POST /api/v1/arbiters/predictions`` (which takes a list of
+   * arbiters and wraps the response in a ``predictions`` array), v2 takes
+   * exactly one arbiter and returns ``{example_id, prediction_id, output,
+   * reasoning, messages}``.
+   */
+  async createPredictionApiV2ArbitersPredictionsPost(
+    request: models.SrcApiV2ArbitersSchemasPredictExampleRequest,
+    options?: RequestOptions,
+  ): Promise<models.PredictExampleResponse> {
+    return unwrapAsync(createPredictionApiV2ArbitersPredictionsPost(
+      this,
+      request,
+      options,
+    ));
+  }
+}