@toloka-platform/sdk 0.1.0-preview.6 → 0.1.0-preview.8

package/examples/video-pair-rating/nodes/merge_op_adjudication/node.ts

@@ -15,18 +15,16 @@ export const mergeOpAdjudication = code("merge_op_adjudication", {
       "Consolidates the overall preference branch: if adjudication ran, emit the adjudicator pick and resolution_method=adjudication; otherwise emit the quorum majority and resolution_method=agreement.",
   },
   envVars: [],
-  fieldProxies: {
-    input: [
-      { field: opNeedsAdjudication, optional: false },
-      { field: opManualValue, optional: true },
-      { field: opAdjudicatedValue, optional: true },
-    ],
-    output: [
-      { field: finalOpValue, optional: false },
-      { field: finalOpResolutionMethod, optional: false },
-      { field: finalOpAdjudicatorId, optional: false },
-    ],
-  },
+  input: [
+    { field: opNeedsAdjudication, optional: false },
+    { field: opManualValue, optional: true },
+    { field: opAdjudicatedValue, optional: true },
+  ],
+  output: [
+    { field: finalOpValue, optional: false },
+    { field: finalOpResolutionMethod, optional: false },
+    { field: finalOpAdjudicatorId, optional: false },
+  ],
   code: {
     code: `from main_types import Inputs, Outputs
 
@@ -38,8 +36,8 @@ async def main(inputs: Inputs) -> Outputs:
             "final_op_value": inputs["op_adjudicated_value"],
             "final_op_resolution_method": "adjudication",
             # Platform limitation (mirrors annotator_id_1/2 in assemble): the
-            # OP adjudicator id is not surfaced as a field proxy from the
-            # generation_sft node in this pilot. Emit null.
+            # OP adjudicator id is not surfaced as an output field from the
+            # generation node in this pilot. Emit null.
             "final_op_adjudicator_id": None,
         }
     return {

package/examples/video-pair-rating/nodes/op_quorum_resolve/node.ts

@@ -18,21 +18,19 @@ export const opQuorumResolve = code("op_quorum_resolve", {
       "Resolves three overall preference votes from the quorum into a majority. If fewer than two votes agree, flags for adjudication and packages the disagreed task payload.",
   },
   envVars: [],
-  fieldProxies: {
-    input: [
-      { field: prompt, optional: false },
-      { field: videoA, optional: false },
-      { field: videoB, optional: false },
-      { field: swap, optional: false },
-      { field: overallManualVotes, optional: false },
-    ],
-    output: [
-      { field: opManualValue, optional: true },
-      { field: opNeedsAdjudication, optional: false },
-      { field: disagreedOpTask, optional: false },
-      { field: raterOpVotes, optional: false },
-    ],
-  },
+  input: [
+    { field: prompt, optional: false },
+    { field: videoA, optional: false },
+    { field: videoB, optional: false },
+    { field: swap, optional: false },
+    { field: overallManualVotes, optional: false },
+  ],
+  output: [
+    { field: opManualValue, optional: true },
+    { field: opNeedsAdjudication, optional: false },
+    { field: disagreedOpTask, optional: false },
+    { field: raterOpVotes, optional: false },
+  ],
   code: {
     code: `from main_types import Inputs, Outputs
 

package/examples/video-pair-rating/nodes/overall_preference_pick/node.ts

@@ -48,7 +48,7 @@ export const overallPreferencePick = quorum("overall_preference_pick", {
   instruction:
     "Watch both videos in full, then pick the one you would ship. This is a single judgment about the whole video, not a sum of its parts. Use tie only when you genuinely have no preference. Unlike the metric rating task, this one shows the pair in its original order, so your pick needs no un-shuffling downstream.",
   ui: {
-    code: "<Field.SelectGroup path={'overall_manual_votes'} options={[{ label: 'First video', value: 'video_a' }, { label: 'Second video', value: 'video_b' }, { label: 'Tie', value: 'tie' }]} />",
+    code: "<Field.RadioGroup path={'overall_manual_votes'} options={[{ label: 'First video', value: 'video_a' }, { label: 'Second video', value: 'video_b' }, { label: 'Tie', value: 'tie' }]} />",
     data: '{"prompt":"a red fox crossing a snowy field at dawn","video_a":"https://example.com/video-a.mp4","video_b":"https://example.com/video-b.mp4"}',
     preprocess: "return {}",
     postprocess: "return {};",

package/examples/video-pair-rating/nodes/rate_pair/node.ts

@@ -96,7 +96,7 @@ export const ratePair = quorum("rate_pair", {
   instruction:
     "Watch both videos in full before answering. For each metric, pick the video that is better on that metric alone, or tie when they are equal. The two videos are presented in random order, so left and right carry no meaning. Different metrics can have different winners; that is expected.",
   ui: {
-    code: "<View.Group><Field.SelectGroup path={'image_text_alignment'} label={'Which video matches the prompt in its imagery?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'motion_text_alignment'} label={'Which video matches the prompt in its motion?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'image_quality'} label={'Which video looks better frame by frame?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'motion_quality'} label={'Which video moves more plausibly?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'subject_background_consistency'} label={'Which video keeps its subject and background stable?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.SelectGroup path={'video_realism'} label={'Which video reads as more real?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /></View.Group>",
+    code: "<View.Card><Field.RadioGroup path={'image_text_alignment'} label={'Which video matches the prompt in its imagery?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.RadioGroup path={'motion_text_alignment'} label={'Which video matches the prompt in its motion?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.RadioGroup path={'image_quality'} label={'Which video looks better frame by frame?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.RadioGroup path={'motion_quality'} label={'Which video moves more plausibly?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.RadioGroup path={'subject_background_consistency'} label={'Which video keeps its subject and background stable?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /><Field.RadioGroup path={'video_realism'} label={'Which video reads as more real?'} options={[{ label: 'Left', value: 'video_1' }, { label: 'Right', value: 'video_2' }, { label: 'Tie', value: 'tie' }]} /></View.Card>",
     data: '{"prompt":"a red fox crossing a snowy field at dawn","left_video":"https://example.com/video-left.mp4","right_video":"https://example.com/video-right.mp4"}',
     preprocess: "return {}",
     postprocess: "return {};",

package/examples/video-pair-rating/nodes/route_adjudication/node.ts

@@ -20,7 +20,5 @@ export const routeAdjudication = match("route_adjudication", {
       ],
     },
   ],
-  fieldProxies: {
-    input: [{ field: needsAdjudication, optional: false }],
-  },
+  input: [{ field: needsAdjudication, optional: false }],
 });

package/examples/video-pair-rating/nodes/route_op_adjudication/node.ts

@@ -20,11 +20,9 @@ export const routeOpAdjudication = match("route_op_adjudication", {
       ],
     },
   ],
-  fieldProxies: {
-    input: [
-      { field: opNeedsAdjudication, optional: false },
-      { field: disagreedOpTask, optional: true },
-      { field: opManualValue, optional: true },
-    ],
-  },
+  input: [
+    { field: opNeedsAdjudication, optional: false },
+    { field: disagreedOpTask, optional: true },
+    { field: opManualValue, optional: true },
+  ],
 });

package/examples/video-pair-rating/nodes/route_overall/node.ts

@@ -20,7 +20,5 @@ export const routeOverall = match("route_overall", {
       ],
     },
   ],
-  fieldProxies: {
-    input: [{ field: needsOverallManual, optional: false }],
-  },
+  input: [{ field: needsOverallManual, optional: false }],
 });

package/examples/video-pair-rating/nodes/shuffle_ab/node.ts

@@ -8,19 +8,17 @@ export const shuffleAb = code("shuffle_ab", {
       "Mints a deterministic record_id from a hash of the prompt and video pair. Swaps the left/right video assignment based on the hash parity to prevent position bias in rater interfaces.",
   },
   envVars: [],
-  fieldProxies: {
-    input: [
-      { field: f.prompt, optional: false },
-      { field: f.videoA, optional: false },
-      { field: f.videoB, optional: false },
-    ],
-    output: [
-      { field: f.recordId, optional: false },
-      { field: f.leftVideo, optional: false },
-      { field: f.rightVideo, optional: false },
-      { field: f.swap, optional: false },
-    ],
-  },
+  input: [
+    { field: f.prompt, optional: false },
+    { field: f.videoA, optional: false },
+    { field: f.videoB, optional: false },
+  ],
+  output: [
+    { field: f.recordId, optional: false },
+    { field: f.leftVideo, optional: false },
+    { field: f.rightVideo, optional: false },
+    { field: f.swap, optional: false },
+  ],
   code: {
     code: `import hashlib
 from main_types import Inputs, Outputs

package/examples/video-pair-rating/pipeline.browser.integration.spec.ts

@@ -0,0 +1,267 @@
+import { expect, test } from "@toloka-platform/sdk/testing";
+import { describe } from "vitest";
+
+import pipeline from "./pipeline";
+import { adjudicate } from "./nodes/adjudicate/node";
+import { adjudicateOp } from "./nodes/adjudicate_op/node";
+import { adjudicationMatch } from "./nodes/adjudication_match/node";
+import { assemble } from "./nodes/assemble/node";
+import { cascade } from "./nodes/cascade/node";
+import { finalizeOverall } from "./nodes/finalize_overall/node";
+import { mergeAdjudication } from "./nodes/merge_adjudication/node";
+import { mergeOpAdjudication } from "./nodes/merge_op_adjudication/node";
+import { opQuorumResolve } from "./nodes/op_quorum_resolve/node";
+import { overallPreferencePick } from "./nodes/overall_preference_pick/node";
+import { ratePair } from "./nodes/rate_pair/node";
+import { shuffleAb } from "./nodes/shuffle_ab/node";
+
+const item = {
+  prompt: "a fox crossing a snowy field",
+  video_a: "https://example.com/video-a.mp4",
+  video_b: "https://example.com/video-b.mp4",
+};
+const metricNames = [
+  "image_text_alignment",
+  "motion_text_alignment",
+  "image_quality",
+  "motion_quality",
+  "subject_background_consistency",
+  "video_realism",
+];
+const canonicalMetrics = Object.fromEntries(metricNames.map((name) => [name, "video_a"]));
+const metricVotes = Object.fromEntries(metricNames.map((name) => [name, ["video_1", "video_1"]]));
+
+describe("video pair rating example", () => {
+  test.code(pipeline, shuffleAb, "shuffles a pair deterministically", async ({ run }) => {
+    const result = await run(item);
+
+    expect(result).toMatchObject({
+      record_id: expect.stringMatching(/^[a-f0-9]{16}$/u),
+      swap: expect.any(Boolean),
+    });
+    expect(new Set([result.left_video, result.right_video])).toEqual(
+      new Set([item.video_a, item.video_b]),
+    );
+  });
+
+  test.code(pipeline, cascade, "resolves unanimous metric votes", async ({ run }) => {
+    await expect(run({ swap: false, ...metricVotes })).resolves.toMatchObject({
+      per_metric_resolved: canonicalMetrics,
+      needs_adjudication: "false",
+      op_value_or_null: "video_a",
+      op_source: "alignment",
+      needs_overall_manual: "false",
+    });
+  });
+
+  test.code(pipeline, mergeAdjudication, "preserves agreed metrics", async ({ run }) => {
+    await expect(
+      run({
+        per_metric_resolved: canonicalMetrics,
+        disagreed_metrics: [],
+      }),
+    ).resolves.toMatchObject({
+      final_metrics: canonicalMetrics,
+      resolution_method: "agreement",
+      op_value_or_null: "video_a",
+      needs_overall_manual: "false",
+    });
+  });
+
+  test.code(pipeline, opQuorumResolve, "resolves an overall majority", async ({ run }) => {
+    await expect(
+      run({
+        ...item,
+        swap: false,
+        overall_manual_votes: ["video_a", "video_a", "video_b"],
+      }),
+    ).resolves.toMatchObject({
+      op_manual_value: "video_a",
+      op_needs_adjudication: "false",
+      rater_op_votes: ["video_a", "video_a", "video_b"],
+    });
+  });
+
+  test.code(pipeline, mergeOpAdjudication, "uses the overall quorum majority", async ({ run }) => {
+    await expect(
+      run({ op_needs_adjudication: "false", op_manual_value: "video_a" }),
+    ).resolves.toEqual({
+      final_op_value: "video_a",
+      final_op_resolution_method: "agreement",
+      final_op_adjudicator_id: null,
+    });
+  });
+
+  test.code(pipeline, finalizeOverall, "finalizes a cascade preference", async ({ run }) => {
+    await expect(
+      run({
+        op_value_or_null: "video_a",
+        op_source: "alignment",
+        needs_overall_manual: "false",
+        final_metrics: canonicalMetrics,
+        resolution_method: "agreement",
+        annotator_id_adjudicator: null,
+      }),
+    ).resolves.toEqual({
+      overall_preference: "video_a",
+      overall_preference_source: "alignment",
+      resolution_method: "agreement",
+      annotator_id_adjudicator: null,
+    });
+  });
+
+  test.code(
+    pipeline,
+    adjudicationMatch,
+    "grades raters against an adjudicated metric",
+    async ({ run }) => {
+      await expect(
+        run({
+          rater_ita_votes: ["video_a", "video_b"],
+          rater_iq_votes: ["video_a", "video_a"],
+          disagreed_metrics: ["image_text_alignment"],
+          final_metrics: canonicalMetrics,
+          needs_overall_manual: "false",
+        }),
+      ).resolves.toEqual({
+        rater_ita_matches_adjudication: [true, false],
+        rater_iq_matches_adjudication: null,
+        rater_op_matches_adjudication: null,
+      });
+    },
+  );
+
+  test.code(pipeline, assemble, "assembles the delivery record", async ({ run }) => {
+    await expect(
+      run({
+        record_id: "record-1",
+        ...item,
+        final_metrics: canonicalMetrics,
+        overall_preference: "video_a",
+        overall_preference_source: "alignment",
+        resolution_method: "agreement",
+        annotator_id_adjudicator: null,
+        rater_ita_votes: ["video_a", "video_a"],
+        rater_mta_votes: ["video_a", "video_a"],
+        rater_iq_votes: ["video_a", "video_a"],
+        rater_mq_votes: ["video_a", "video_a"],
+        rater_sbc_votes: ["video_a", "video_a"],
+        rater_vr_votes: ["video_a", "video_a"],
+        rater_ita_matches_adjudication: null,
+        rater_iq_matches_adjudication: null,
+        rater_op_matches_adjudication: null,
+      }),
+    ).resolves.toMatchObject({
+      delivery_record: {
+        record_id: "record-1",
+        video_a_url: item.video_a,
+        video_b_url: item.video_b,
+        overall_preference: "video_a",
+        timestamp: expect.stringMatching(/Z$/u),
+      },
+    });
+  });
+
+  test.ui(pipeline, ratePair, "submits independent metric ratings", async ({ render }) => {
+    const session = await render({
+      data: { prompt: item.prompt, left_video: item.video_a, right_video: item.video_b },
+    });
+    for (const metric of metricNames) await session.setValue(metric, "video_1");
+
+    await expect(session.submit()).resolves.toMatchObject(
+      Object.fromEntries(metricNames.map((name) => [name, "video_1"])),
+    );
+    await session.close();
+  });
+
+  test.ui(pipeline, adjudicate, "submits disputed metric decisions", async ({ render }) => {
+    const session = await render({
+      data: { ...item, disagreed_metrics: ["image_quality", "motion_quality"] },
+    });
+    await session.setValue("adjudicated_metrics.image_quality", "video_a");
+    await session.setValue("adjudicated_metrics.motion_quality", "video_b");
+
+    await expect(session.submit()).resolves.toMatchObject({
+      adjudicated_metrics: { image_quality: "video_a", motion_quality: "video_b" },
+    });
+    await session.close();
+  });
+
+  test.ui(
+    pipeline,
+    overallPreferencePick,
+    "submits an overall preference vote",
+    async ({ render }) => {
+      const session = await render({ data: item });
+      await session.setValue("overall_manual_votes", "video_a");
+
+      await expect(session.submit()).resolves.toMatchObject({ overall_manual_votes: "video_a" });
+      await session.close();
+    },
+  );
+
+  test.ui(pipeline, adjudicateOp, "submits an overall adjudication", async ({ render }) => {
+    const session = await render({ data: item });
+    await session.setValue("op_adjudicated_value", "video_b");
+
+    await expect(session.submit()).resolves.toMatchObject({ op_adjudicated_value: "video_b" });
+    await session.close();
+  });
+
+  test.pipeline(pipeline, "rates and assembles an agreed pair", async ({ renderUi, runCode }) => {
+    const shuffled = await runCode(shuffleAb, item);
+    const session = await renderUi(ratePair, {
+      data: {
+        prompt: item.prompt,
+        left_video: shuffled.left_video,
+        right_video: shuffled.right_video,
+      },
+    });
+    for (const metric of metricNames) await session.setValue(metric, "video_1");
+    const rating = await session.submit();
+    const votes = Object.fromEntries(
+      metricNames.map((name) => [name, [rating[name], rating[name]]]),
+    );
+    const resolved = await runCode(cascade, { swap: shuffled.swap, ...votes });
+    const merged = await runCode(mergeAdjudication, {
+      per_metric_resolved: resolved.per_metric_resolved,
+      disagreed_metrics: resolved.disagreed_metrics,
+    });
+    const overall = await runCode(finalizeOverall, {
+      op_value_or_null: merged.op_value_or_null,
+      op_source: merged.op_source,
+      needs_overall_manual: merged.needs_overall_manual,
+      final_metrics: merged.final_metrics,
+      resolution_method: merged.resolution_method,
+      annotator_id_adjudicator: merged.annotator_id_adjudicator,
+    });
+    const matches = await runCode(adjudicationMatch, {
+      rater_ita_votes: resolved.rater_ita_votes,
+      rater_iq_votes: resolved.rater_iq_votes,
+      disagreed_metrics: resolved.disagreed_metrics,
+      final_metrics: merged.final_metrics,
+      needs_overall_manual: merged.needs_overall_manual,
+    });
+    const assembled = await runCode(assemble, {
+      record_id: shuffled.record_id,
+      ...item,
+      final_metrics: merged.final_metrics,
+      ...overall,
+      rater_ita_votes: resolved.rater_ita_votes,
+      rater_mta_votes: resolved.rater_mta_votes,
+      rater_iq_votes: resolved.rater_iq_votes,
+      rater_mq_votes: resolved.rater_mq_votes,
+      rater_sbc_votes: resolved.rater_sbc_votes,
+      rater_vr_votes: resolved.rater_vr_votes,
+      ...matches,
+    });
+
+    expect(assembled).toMatchObject({
+      delivery_record: {
+        record_id: shuffled.record_id,
+        overall_preference_source: "alignment",
+      },
+    });
+    await session.close();
+  });
+});

package/openapi/gen/api.ts

@@ -71,6 +71,9 @@ import type {
   RunItem,
   RunItemId,
   RunJob,
+  SampleDatasetItemsBody,
+  SampleJob,
+  SampleResult,
   SetProjectSecretBody,
   UpdatePipelineBody,
   UpdateProjectBody,
@@ -564,28 +567,31 @@ export const finalizeDatasetUpload = async (
   });
 };
 
-export const getGetDatasetUploadUrl = (uploadId: UploadId) => {
-  return `/api/v2-beta/uploads/${uploadId}`;
+export const getCancelDatasetUploadUrl = (uploadId: UploadId) => {
+  return `/api/v2-beta/uploads/${uploadId}/cancel`;
 };
 
-export const getDatasetUpload = async (
+export const cancelDatasetUpload = async (
   uploadId: UploadId,
   options?: RequestInit,
-): Promise<UploadJob> => {
-  return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId), {
+): Promise<void> => {
+  return potatoFetch<void>(getCancelDatasetUploadUrl(uploadId), {
     ...options,
-    method: "GET",
+    method: "POST",
   });
 };
 
-export const getCancelDatasetUploadUrl = (uploadId: UploadId) => {
-  return `/api/v2-beta/uploads/${uploadId}/cancel`;
+export const getGetDatasetUploadUrl = (uploadId: UploadId) => {
+  return `/api/v2-beta/uploads/${uploadId}`;
 };
 
-export const cancelDatasetUpload = async (uploadId: UploadId, options?: RequestInit): Promise<void> => {
-  return potatoFetch<void>(getCancelDatasetUploadUrl(uploadId), {
+export const getDatasetUpload = async (
+  uploadId: UploadId,
+  options?: RequestInit,
+): Promise<UploadJob> => {
+  return potatoFetch<UploadJob>(getGetDatasetUploadUrl(uploadId), {
     ...options,
-    method: "POST",
+    method: "GET",
   });
 };
 
@@ -745,6 +751,37 @@ export const cancelPipelineRun = async (runId: RunId, options?: RequestInit): Pr
   });
 };
 
+export const getSampleDatasetItemsUrl = (datasetId: DatasetId) => {
+  return `/api/v2-beta/datasets/${datasetId}/sample`;
+};
+
+export const sampleDatasetItems = async (
+  datasetId: DatasetId,
+  sampleDatasetItemsBody: SampleDatasetItemsBody,
+  options?: RequestInit,
+): Promise<SampleResult> => {
+  return potatoFetch<SampleResult>(getSampleDatasetItemsUrl(datasetId), {
+    ...options,
+    method: "POST",
+    headers: { "Content-Type": "application/json", ...options?.headers },
+    body: JSON.stringify(sampleDatasetItemsBody),
+  });
+};
+
+export const getGetDatasetSampleUrl = (sampleId: string) => {
+  return `/api/v2-beta/samples/${sampleId}`;
+};
+
+export const getDatasetSample = async (
+  sampleId: string,
+  options?: RequestInit,
+): Promise<SampleJob> => {
+  return potatoFetch<SampleJob>(getGetDatasetSampleUrl(sampleId), {
+    ...options,
+    method: "GET",
+  });
+};
+
 export const getCreateDatasetExportUrl = (datasetId: DatasetId) => {
   return `/api/v2-beta/datasets/${datasetId}/exports`;
 };

package/openapi/gen/models/createDatasetExportBody.ts

@@ -1,4 +1,4 @@
+import type { CreateDatasetExportBodyOneOf } from './createDatasetExportBodyOneOf';
+import type { CreateDatasetExportBodyOneOfThree } from './createDatasetExportBodyOneOfThree';
 
-export type CreateDatasetExportBody = {
-  fields: string[];
-};
+export type CreateDatasetExportBody = CreateDatasetExportBodyOneOf | CreateDatasetExportBodyOneOfThree;

package/openapi/gen/models/createDatasetExportBodyOneOf.ts

@@ -0,0 +1,6 @@
+import type { CreateDatasetExportBodyOneOfFormat } from './createDatasetExportBodyOneOfFormat';
+
+export type CreateDatasetExportBodyOneOf = {
+  format?: CreateDatasetExportBodyOneOfFormat;
+  fields: string[];
+};

package/openapi/gen/models/createDatasetExportBodyOneOfFormat.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetExportBodyOneOfFormat = 'json-array';

package/openapi/gen/models/createDatasetExportBodyOneOfThree.ts

@@ -0,0 +1,10 @@
+import type { CreateDatasetExportBodyOneOfThreeFormat } from './createDatasetExportBodyOneOfThreeFormat';
+import type { CreateDatasetExportBodyOneOfThreeContract } from './createDatasetExportBodyOneOfThreeContract';
+import type { CreateDatasetExportBodyOneOfThreeItemFilter } from './createDatasetExportBodyOneOfThreeItemFilter';
+
+export type CreateDatasetExportBodyOneOfThree = {
+  format: CreateDatasetExportBodyOneOfThreeFormat;
+  contract: CreateDatasetExportBodyOneOfThreeContract;
+  itemFilter?: CreateDatasetExportBodyOneOfThreeItemFilter;
+  validateOnly?: boolean;
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeContract.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetExportBodyOneOfThreeContract = 'openai-chat-v1';

package/openapi/gen/models/createDatasetExportBodyOneOfThreeFormat.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetExportBodyOneOfThreeFormat = 'training-jsonl';

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilter.ts

@@ -0,0 +1,9 @@
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItem } from './createDatasetExportBodyOneOfThreeItemFilterFieldValuesItem';
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItem } from './createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItem';
+
+export type CreateDatasetExportBodyOneOfThreeItemFilter = {
+  fieldValues?: CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItem[];
+  fieldSources?: CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItem[];
+  missingRevisionFields?: string[];
+  createdBefore?: string;
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItem.ts

@@ -0,0 +1,6 @@
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItem } from './createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItem';
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItem = {
+  fieldId: string;
+  sources: CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItem[];
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOf } from './createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOf';
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOfTwo } from './createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOfTwo';
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItem = CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOf | CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOfTwo;

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOf.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOf = {
+  type: 'user';
+  userId: string;
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOfTwo.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldSourcesItemSourcesItemOneOfTwo = {
+  type: 'system';
+  source: string;
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldValuesItem.ts

@@ -0,0 +1,12 @@
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemOperator } from './createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemOperator';
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemValue } from './createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemValue';
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItem } from './createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItem';
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItem = {
+  jsonPath: string;
+  operator: CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemOperator;
+  value: CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemValue;
+  fieldId: string;
+  latestOnly?: boolean;
+  sources?: CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItem[];
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemOperator.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemOperator = 'text_eq' | 'text_neq';

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOf } from './createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOf';
+import type { CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOfTwo } from './createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOfTwo';
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItem = CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOf | CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOfTwo;

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOf.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOf = {
+  type: 'user';
+  userId: string;
+};

package/openapi/gen/models/createDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOfTwo.ts

@@ -0,0 +1,5 @@
+
+export type CreateDatasetExportBodyOneOfThreeItemFilterFieldValuesItemSourcesItemOneOfTwo = {
+  type: 'system';
+  source: string;
+};