@toloka-platform/sdk 0.11.3 → 0.12.0

package/dist/cli/toloka.js.jsc.sha256

@@ -1 +1 @@
-6f99f48f6bd7c933cd5d2f6b2382d9c4149e6cfb4a39a32364d49994a16f436e  toloka.js.jsc
+305f65ba5180216b7aff18c19fb093165f8bab01a8b33e5899f1ece42db9af8b  toloka.js.jsc

package/dist/cli/toloka.js.sha256

@@ -1 +1 @@
-a038b95e14fe030c3d9b59182799dc89f8c76fd501fe42036831ea3d1daa27c5  toloka.js
+7b5e7b3dc4fabe6f103616a89cf7418aed62482596e9b8482e8e88915e7a967d  toloka.js

package/docs/cli.md

@@ -384,8 +384,8 @@ Create a reusable Training draft, price it, and run it.
 ```sh
 toloka training list [--json]
 toloka training get <name-or-id> [--json]
-toloka training create <name> [--method sft|gisting] (--base-model <id> | --model-version <id>) --dataset <id> [--train-filter field=value] [--validation-dataset <id> [--validation-filter field=value]] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
-toloka training update <name-or-id> [--base-model <id> | --model-version <id>] [--dataset <id>] [--train-filter field=value] [--validation-dataset <id> [--validation-filter field=value]] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
+toloka training create <name> [--method sft|gisting] (--base-model <id> | --model-version <id>) (--dataset <name-or-id> | --slice <id>) [--split-column <name-or-id>] [--parts <names>] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
+toloka training update <name-or-id> [--base-model <id> | --model-version <id>] [--dataset <name-or-id> | --slice <id>] [--split-column <name-or-id>] [--parts <names>] [--prompt-file <path>] [--lora-rank 8|16|32 | --gist-tokens 8|32|64|1/4|1/8|1/16|1/32] [--epochs 1..5] [--learning-rate <rate>] [--batch-size 8|16|32|64] [--max-sequence-length <tokens>] [--json]
 toloka training cost <name-or-id> [--idempotency-key <key>] [--json]
 toloka training run <name-or-id> [--estimate-file <path>] [--version-name <name>] [--idempotency-key <key>] [--json]
 toloka training runs <name-or-id> [--json]
@@ -398,6 +398,8 @@ toloka training metrics <training-run-id> [--key <metric>] [--resolution <n>] [-
 
 Hyperparameters are optional flags on `training create` and `training update`: `--epochs 1..5` (default 3), `--learning-rate` (SFT 0.00001–0.001, default 0.00015; gisting 0.001–0.3, default 0.03), `--batch-size 8|16|32|64` (default 8; sequences per optimizer step across all GPUs) and `--max-sequence-length 64..16384` (default 12288 for SFT, 3072 for gisting) apply to both methods; `--lora-rank 8|16|32` (default 16) is SFT-only and `--gist-tokens` (default `1/8`) is gisting-only — passing one to the other method fails before any request. `--gist-tokens` takes an absolute count `8|32|64` or a fraction of the prompt being compressed (`1/4`, `1/8`, `1/16`, `1/32`), which the run resolves to `ceil(prompt tokens / N)` clamped to 8..256. `--regime` and `--eval-steps` no longer exist. `training update` has no `--method` flag: the method stays as created, and every flag you omit keeps its current value. `training cost` is blocked when the longest example exceeds `--max-sequence-length` or when the training selection leaves fewer rows than `--batch-size` after the 10% holdout. `training get` prints the resolved recipe, so omitted flags are visible as their defaults.
 
+A Training learns on a ready dataset slice that freezes a split column, and `training create` needs `--dataset` or `--slice`. `--dataset <name-or-id>` fills the empty cells of the dataset's split column (a new `split` column, 80/10/10, when it has none), freezes a slice named after the Training, and trains on it; it waits up to 10 minutes for each step and prints one line per step before `Created training`. A split column adopted from an ordinary column has no shares, so `--dataset` does not fill it; give it shares first with `toloka dataset split <dataset> --column <name> --parts <name>=<roles>:<percent>,...`. `--slice <id>` takes a slice frozen with `toloka dataset slice create`. With several split columns, `--split-column` picks the one to train with. The Training learns on the column's train parts, or the ones `--parts` names, and validates on its validate parts, including a part that both validates and tests; without validation rows, the run holds out 10% of the training rows. Rows without a part are never trained on. `training update` keeps the slice, split column and train parts. A new `--dataset` or `--slice` resets the split column and train parts unless you pass them too; `--dataset` splits again and freezes a new slice named after the Training. `training get` prints the slice, split column and train parts. `training cost` leaves out rows that any split column now puts in a test part, a validate + test part of the Training's own column apart, and prints how many as `Held-out test rows`. A Training saved before split slices were required is refused by `training cost` until `training update` gives it one.
+
 ## dataset
 
 Catalog and row commands for datasets in the selected project. Name or id is accepted; duplicate names must be addressed by id.
@@ -406,8 +408,14 @@ Catalog and row commands for datasets in the selected project. Name or id is acc
 toloka dataset list
 toloka dataset create <name>
 toloka dataset fields <name>
+toloka dataset columns <name> [--json]
 toloka dataset load <name> --out <file> [--limit <n>] [--timeout <ms>]
 toloka dataset upload <name> <file>
+toloka dataset split <name> [--column <name>] [--ratios 80/10/10 [--validate-on-test] | --parts <name[=roles][:percent],…>] [--balance-by <field>] [--seed <n>] [--filter field=value… | --slice <slice-id>] [--no-wait] [--timeout <ms>] [--json]
+toloka dataset slice create <name> [--name <name>] [--filter field=value]… [--freeze <columns>] [--no-wait] [--timeout <ms>] [--json]
+toloka dataset slice create <name> --from <slice-id> [--name <name>] [--freeze <columns>] [--no-wait] [--timeout <ms>] [--json]
+toloka dataset slice list <name>
+toloka dataset slice show <slice-id> [--json]
 ```
 
 `dataset list` prints live `name` and id. It does not page items.
@@ -416,10 +424,20 @@ toloka dataset upload <name> <file>
 
 `dataset fields` prints inferred `field()` TypeScript, or `Dataset <name> has no inferred fields yet.`
 
+`dataset columns` prints each visible column with its id and, for a split column, its status and its parts with shares and roles, for example `ready · train 80% (train), validate 10% (validate), test 10% (test)`. `--json` prints every field with its `split`.
+
 `dataset load` starts a platform export, waits for it (default 60s; pass `--timeout`), downloads the JSON array, and writes JSONL to `--out`. `--limit` slices after download; it still waits for the full export. On timeout the message names the export id. Failed downloads and invalid payloads leave `--out` untouched.
 
 `dataset upload` accepts `.json` arrays, `.jsonl` files with one object per line, and `.csv` files with a header row. The CLI infers the format from the extension and uploads the original bytes without conversion. If the blob transfer or finalization fails, the CLI cancels the started upload before returning the error, so another upload can start immediately and may reuse the same filename. Field schemas are immutable after the first successful upload: you can add columns, never alter or remove one. See [datasets](./datasets.md).
 
+`dataset split` fills a split column: every row that has no value in it gets a part, sampled by share, and rows that already have a part keep it, so a test row stays a test row as the dataset grows. `--column` names the column (default `split`). A new name creates it; the name of a split column fills its empty cells with the shares, balancing column and seed of its last fill; the name of an ordinary column whose values name the parts makes it a split column without placing anything. `--ratios` takes whole percentages for `train`, `validate` and `test` that add up to 100 (default `80/10/10` for a new column); a 0% part is left out. `--parts` takes `name[=roles][:percent]` entries with roles `train`, `validate`, `test`, `validate+test` or `none`, for example `train:70,dev=validate:10,holdout=test:20`; a part named after a role takes it without `=roles`. To make an ordinary column a split column, `--parts` without percentages names the parts its values hold; without `--parts`, roles follow the values `train`, `validation`, `validate`, `val`, `dev` and `test`, and every value must be one of them. A part keeps its roles across fills, and the column keeps the shares of its last fill. `--validate-on-test` makes the test part the validation set too, the usual split when data is scarce; it needs a validate ratio of 0, for example `--ratios 80/0/20 --validate-on-test`, and the test score is then not fully held out. `--balance-by` shares out the rows of every label value on their own, so each part gets about the same mix of labels, though a label with only a few rows can still miss a part; a column with more than 1,000 distinct values fails the fill. `--seed` fixes the row order; it is generated when omitted and kept by the column. Shares carry over: rows that already have a part count toward it, so the column keeps its proportions as rows are added. `--filter field=value` (repeatable) places only the rows that match when the fill starts, and `--slice` only the rows of a slice, waiting while it is still freezing. Rows uploaded during a fill wait for the next one. The command waits up to 60 seconds for the rows to be placed (`--timeout <ms>` sets the wait), prints the column's parts and the rows each holds, and exits with the error when the fill fails; when the wait runs out the fill keeps running. `--no-wait` returns at once, and `dataset columns` shows the progress. A fill is refused while the same column is still filling.
+
+A dataset can have several split columns. A row that any of them puts in a test part never reaches training, nor validation unless it sits in a validate + test part of the Training's own split column, so a column such as `--column holdout --parts holdout=test:10,rest=none:90` holds rows out of every Training. Name the column to train with through `training create --split-column`.
+
+`dataset slice create` freezes rows at a cutoff: the rows that match every `--filter field=value` (the top-level field equals the value; repeat the flag for more fields), or every row. The slice's id (`dsl.…`) always selects the same rows, and its frozen columns always read as they were just before the cutoff. `--name` tells slices apart (default `Slice 1`, `Slice 2` and so on). Rows uploaded later are never in it, and it is refused while an upload to the dataset is still running or a split column is still filling, so run it after `dataset upload` and `dataset split` finish. `--freeze` names the columns to freeze (default: every column); split columns are always frozen, so a slice records the parts as they were. The other columns read their latest values, and so do extra filters on a slice, such as field values or excluded parts. `--from <slice-id>` takes a ready slice again: its filters and, unless `--freeze` says otherwise, its frozen columns at a new cutoff, so rows added since join, rows that no longer match drop out, and frozen columns take their current values. `--from` refuses `--filter`. The command waits up to 60 seconds for the rows to be frozen (`--timeout <ms>` sets the wait; the slice keeps freezing when it runs out) and exits with the error when the slice fails, for example when no row matches; `--no-wait` returns at once, and `dataset slice show` reports the name, status, row count, filters and frozen columns. A slice that matches no row fails.
+
+`dataset slice list` prints the dataset's slices, newest first, with their names and the slice each one was taken from. Every slice stays readable by id.
+
 ## report
 
 Preview and submit one Markdown issue report through the CLI's existing PostHog telemetry client. The command is project-independent: it does not read `toloka.json`, walk up to find a project root, require credentials, or call the Toloka API.

package/docs/datasets.md

@@ -59,7 +59,7 @@ Plan: 4 changes
 
 ## Immutability
 
-**A dataset field can be added. It can never be altered or removed after creation.**
+**A dataset field can be added. It can never be altered or removed after creation.** One exception: `dataset split` turning an ordinary column into a split column replaces its JSON Schema with an enum of the part names, which every value the column holds already matches.
 
 The platform API exposes exactly two field operations:
 
@@ -146,6 +146,45 @@ export const faces = field(
 
 Inference runs once, after the first upload attaches rows to the dataset. When no upload has completed, the command prints "Dataset X has no inferred fields yet." Upload a representative file first.
 
+## Split a dataset and freeze a slice
+
+A split column puts each row in a part such as train, validate or test. A slice freezes a set of rows, and it always freezes the split columns.
+
+```sh
+toloka dataset split banking77 --ratios 80/10/10 --balance-by intent
+toloka dataset slice create banking77 --name "intent eval" --freeze text,intent
+```
+
+`dataset split` fills a split column, `split` unless `--column` names another: every row without a part gets one, sampled by share. Each part has roles. Trainings learn on `train` parts and validate on `validate` parts; `test` parts are held out: no training learns on a row that any split column puts in a test part, and none validates on one unless it sits in a validate + test part of the training's own split column. A part with no roles is for anything else. A part can both validate and test, the usual split when data is scarce (`--ratios 80/0/20 --validate-on-test`); its test score is then not fully held out. A train part has no other role. `--ratios` covers `train`, `validate` and `test`; `--parts train:70,calibration=none:10,validate:10,test:10` names other parts. `toloka dataset columns banking77` shows the split columns with their parts and roles.
+
+A split only fills empty cells. After an upload, run it again: the new rows join the parts so that the column keeps its shares, balanced by the same column with the same seed, and every row that already had a part keeps it, so no test row moves into training. Rows without a part are never trained on. To adopt a column that already names each row's part, such as a top-level Hugging Face `split` column, pass its name: `toloka dataset split banking77 --column split`. Roles follow the values `train`, `validation`, `validate`, `val`, `dev` and `test`; `--parts train,dev=validate,test` maps other names.
+
+A slice takes the rows that match its filters (`--filter intent=card_arrival`, repeated for more fields), or every row, at a cutoff. Its id (`dsl.…`) always selects the same rows, and it reads its frozen columns as they were just before the cutoff, so those values never change either. By default every column is frozen; `--freeze text,intent` picks the columns instead, split columns are always added, and the others read their latest values. Rows uploaded later are never in a slice, and a slice cannot be taken while an upload to the dataset is still running or a split column is still filling. Reading through a slice, the rows and its frozen columns, split parts included, are as of the slice cutoff; extra filters you add, such as field values or excluded parts, match the latest values. `--from <slice-id>` takes a slice again at a new cutoff: rows added since join and rows that no longer match drop out.
+
+A Training learns on a slice that freezes a split column: pass `--slice <id>` (`sliceId` in the API), or `--dataset <name>` to split the dataset and freeze a slice named after the Training in one step. It learns on the train parts and validates on the validate parts of that column; `--split-column` (`splitFieldId`) picks the column when the slice freezes several, and `--parts` (`trainParts`) picks among the train parts.
+
+From the SDK:
+
+```ts
+const column = await client.datasets.split({
+  datasetId,
+  parts: [
+    { name: "train", roles: ["train"], share: 0.7 },
+    { name: "calibration", roles: [], share: 0.1 },
+    { name: "validate", roles: ["validate"], share: 0.1 },
+    { name: "test", roles: ["test"], share: 0.1 },
+  ],
+  balanceBy: "intent",
+});
+const filled = await client.waitFor({ type: "datasetSplit", datasetId, column: column.name });
+const slice = await client.datasets.createSlice({ datasetId, name: "intent eval", frozenColumns: ["text", "intent"] });
+const ready = await client.waitFor({ type: "datasetSlice", sliceId: slice.id });
+```
+
+`split` returns the column, a dataset field whose `split` has the parts, the recipe and a `status` of `filling`, `ready` or `failed`. `waitFor({ type: "datasetSplit", datasetId, column })` resolves once the column stops filling, with `split.lastFill` counting the rows it placed, the rows that already had a part, and the rows per part. Pass `slice: sliceId` or an `itemFilter` to place only those rows. To adopt a column, pass its name and parts without shares: `{ datasetId, column: "split", parts: [{ name: "train", roles: ["train"] }, { name: "validation", roles: ["validate"] }, { name: "test", roles: ["test"] }] }`, or omit `parts` to infer the roles from the values. To take a slice again, pass `{ datasetId, fromSlice: sliceId }` to `createSlice`.
+
+Pipeline runs accept `slice: { sliceId }`, `parts: { fieldId, names: ["test"] }` and `excludeParts: [{ fieldId, names }]` in their row filter. `parts` reads the column as it was at the slice's cutoff when the same filter selects a slice that freezes it. A run that selects through a slice reads the slice's frozen columns as they were at the cutoff and every other column as usual.
+
 ## What plan refuses
 
 `plan` is read-only and reports everything `apply` will not do. Two dataset-related refusals are safety properties, not obstacles:

package/openapi/gen/api.ts

@@ -11,6 +11,7 @@ import type {
   CreateDatasetExportBody,
   CreateDatasetField200,
   CreateDatasetFieldBody,
+  CreateDatasetSliceBody,
   CreateDatasetUpload200,
   CreateDatasetUploadBody,
   CreatePipelineCheckBody,
@@ -23,7 +24,9 @@ import type {
   CreateTrainingRunBody,
   CurrentUser,
   Dataset,
+  DatasetField,
   DatasetId,
+  DatasetSlice,
   EstimatePipelineCostBody,
   EstimateTrainingCostBody,
   ExportId,
@@ -40,6 +43,8 @@ import type {
   ListDatasetFieldsParams,
   ListDatasetItems200,
   ListDatasetItemsParams,
+  ListDatasetSlices200,
+  ListDatasetSlicesParams,
   ListDeliveryOrders200,
   ListGenerationModels200,
   ListModelVersions200,
@@ -96,6 +101,7 @@ import type {
   SampleResult,
   ScopedToken,
   SetProjectSecretBody,
+  SplitDatasetBody,
   Training,
   TrainingCostEstimate,
   TrainingCostEstimateInputSet,
@@ -1511,6 +1517,103 @@ export const getDatasetSample = async (sampleId: string, options?: RequestInit):
 
 
 
+export const getCreateDatasetSliceUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/slices`
+}
+
+export const createDatasetSlice = async (datasetId: DatasetId,
+    createDatasetSliceBody: CreateDatasetSliceBody, options?: RequestInit): Promise<DatasetSlice> => {
+  
+  return potatoFetch<DatasetSlice>(getCreateDatasetSliceUrl(datasetId),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      createDatasetSliceBody,)
+  }
+);}
+
+
+
+export const getListDatasetSlicesUrl = (datasetId: DatasetId,
+    params?: ListDatasetSlicesParams,) => {
+  const normalizedParams = new URLSearchParams();
+
+  Object.entries(params || {}).forEach(([key, value]) => {
+    
+    if (value !== undefined) {
+      normalizedParams.append(key, value === null ? 'null' : value.toString())
+    }
+  });
+
+  const stringifiedParams = normalizedParams.toString();
+
+  return stringifiedParams.length > 0 ? `/api/v2-beta/datasets/${datasetId}/slices?${stringifiedParams}` : `/api/v2-beta/datasets/${datasetId}/slices`
+}
+
+export const listDatasetSlices = async (datasetId: DatasetId,
+    params?: ListDatasetSlicesParams, options?: RequestInit): Promise<ListDatasetSlices200> => {
+  
+  return potatoFetch<ListDatasetSlices200>(getListDatasetSlicesUrl(datasetId,params),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getGetDatasetSliceUrl = (sliceId: string,) => {
+
+
+  
+
+  return `/api/v2-beta/slices/${sliceId}`
+}
+
+export const getDatasetSlice = async (sliceId: string, options?: RequestInit): Promise<DatasetSlice> => {
+  
+  return potatoFetch<DatasetSlice>(getGetDatasetSliceUrl(sliceId),
+  {      
+    ...options,
+    method: 'GET'
+    
+    
+  }
+);}
+
+
+
+export const getSplitDatasetUrl = (datasetId: DatasetId,) => {
+
+
+  
+
+  return `/api/v2-beta/datasets/${datasetId}/split`
+}
+
+export const splitDataset = async (datasetId: DatasetId,
+    splitDatasetBody: SplitDatasetBody, options?: RequestInit): Promise<DatasetField> => {
+  
+  return potatoFetch<DatasetField>(getSplitDatasetUrl(datasetId),
+  {      
+    ...options,
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json', ...options?.headers },
+    body: JSON.stringify(
+      splitDatasetBody,)
+  }
+);}
+
+
+
 export const getCreateDatasetExportUrl = (datasetId: DatasetId,) => {
 
 

package/openapi/gen/models/attachPipelineDatasetBodyItemFilter.ts

@@ -1,9 +1,15 @@
 import type { AttachPipelineDatasetBodyItemFilterFieldValuesItem } from './attachPipelineDatasetBodyItemFilterFieldValuesItem';
 import type { AttachPipelineDatasetBodyItemFilterFieldSourcesItem } from './attachPipelineDatasetBodyItemFilterFieldSourcesItem';
+import type { AttachPipelineDatasetBodyItemFilterSlice } from './attachPipelineDatasetBodyItemFilterSlice';
+import type { AttachPipelineDatasetBodyItemFilterParts } from './attachPipelineDatasetBodyItemFilterParts';
+import type { AttachPipelineDatasetBodyItemFilterExcludePartsItem } from './attachPipelineDatasetBodyItemFilterExcludePartsItem';
 
 export type AttachPipelineDatasetBodyItemFilter = {
   fieldValues?: AttachPipelineDatasetBodyItemFilterFieldValuesItem[];
   fieldSources?: AttachPipelineDatasetBodyItemFilterFieldSourcesItem[];
   missingRevisionFields?: string[];
+  slice?: AttachPipelineDatasetBodyItemFilterSlice;
+  parts?: AttachPipelineDatasetBodyItemFilterParts;
+  excludeParts?: AttachPipelineDatasetBodyItemFilterExcludePartsItem[];
   createdBefore?: string;
 };

package/openapi/gen/models/attachPipelineDatasetBodyItemFilterExcludePartsItem.ts

@@ -0,0 +1,5 @@
+
+export type AttachPipelineDatasetBodyItemFilterExcludePartsItem = {
+  fieldId: string;
+  names: string[];
+};

package/openapi/gen/models/attachPipelineDatasetBodyItemFilterParts.ts

@@ -0,0 +1,5 @@
+
+export type AttachPipelineDatasetBodyItemFilterParts = {
+  fieldId: string;
+  names: string[];
+};

package/openapi/gen/models/attachPipelineDatasetBodyItemFilterSlice.ts

@@ -0,0 +1,4 @@
+
+export type AttachPipelineDatasetBodyItemFilterSlice = {
+  sliceId: string;
+};

package/openapi/gen/models/createDatasetSliceBody.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetSliceBodyAnyOf } from './createDatasetSliceBodyAnyOf';
+import type { CreateDatasetSliceBodyAnyOfOnethree } from './createDatasetSliceBodyAnyOfOnethree';
+
+export type CreateDatasetSliceBody = CreateDatasetSliceBodyAnyOf | CreateDatasetSliceBodyAnyOfOnethree;

package/openapi/gen/models/createDatasetSliceBodyAnyOf.ts

@@ -0,0 +1,7 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilter } from './createDatasetSliceBodyAnyOfItemFilter';
+
+export type CreateDatasetSliceBodyAnyOf = {
+  name?: string;
+  itemFilter?: CreateDatasetSliceBodyAnyOfItemFilter;
+  frozenColumns?: string[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilter.ts

@@ -0,0 +1,8 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItem';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItem';
+
+export type CreateDatasetSliceBodyAnyOfItemFilter = {
+  fieldValues?: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItem[];
+  fieldSources?: CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItem[];
+  missingRevisionFields?: string[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItem.ts

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

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo } from './createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItem = CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf | CreateDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo;

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOf.ts

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

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldSourcesItemSourcesItemOneOfTwo.ts

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

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItem.ts

@@ -0,0 +1,12 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItem = {
+  jsonPath: string;
+  operator: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator;
+  value: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue;
+  fieldId: string;
+  latestOnly?: boolean;
+  sources?: CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem[];
+};

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemOperator.ts

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

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf';
+import type { CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo } from './createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo';
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItem = CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf | CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo;

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOf.ts

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

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemSourcesItemOneOfTwo.ts

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

package/openapi/gen/models/createDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue.ts

@@ -0,0 +1,2 @@
+
+export type CreateDatasetSliceBodyAnyOfItemFilterFieldValuesItemValue = string | number | boolean | null;

package/openapi/gen/models/createDatasetSliceBodyAnyOfOnethree.ts

@@ -0,0 +1,6 @@
+
+export type CreateDatasetSliceBodyAnyOfOnethree = {
+  name?: string;
+  fromSlice: string;
+  frozenColumns?: string[];
+};

package/openapi/gen/models/datasetField.ts

@@ -1,6 +1,7 @@
 import type { DatasetFieldId } from './datasetFieldId';
 import type { DatasetFieldDescription } from './datasetFieldDescription';
 import type { DatasetFieldJsonSchema } from './datasetFieldJsonSchema';
+import type { DatasetFieldSplit } from './datasetFieldSplit';
 
 export interface DatasetField {
   id: DatasetFieldId;
@@ -8,5 +9,6 @@ export interface DatasetField {
   description: DatasetFieldDescription;
   jsonSchema: DatasetFieldJsonSchema;
   internal: boolean;
+  split: DatasetFieldSplit;
   createdAt: string;
 }

package/openapi/gen/models/datasetFieldSplit.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOf } from './datasetFieldSplitAnyOf';
+
+export type DatasetFieldSplit = DatasetFieldSplitAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOf.ts

@@ -0,0 +1,15 @@
+import type { DatasetFieldSplitAnyOfPartsItem } from './datasetFieldSplitAnyOfPartsItem';
+import type { DatasetFieldSplitAnyOfRecipe } from './datasetFieldSplitAnyOfRecipe';
+import type { DatasetFieldSplitAnyOfStatus } from './datasetFieldSplitAnyOfStatus';
+import type { DatasetFieldSplitAnyOfProgress } from './datasetFieldSplitAnyOfProgress';
+import type { DatasetFieldSplitAnyOfLastFill } from './datasetFieldSplitAnyOfLastFill';
+import type { DatasetFieldSplitAnyOfError } from './datasetFieldSplitAnyOfError';
+
+export type DatasetFieldSplitAnyOf = {
+  parts: DatasetFieldSplitAnyOfPartsItem[];
+  recipe: DatasetFieldSplitAnyOfRecipe;
+  status: DatasetFieldSplitAnyOfStatus;
+  progress: DatasetFieldSplitAnyOfProgress;
+  lastFill: DatasetFieldSplitAnyOfLastFill;
+  error: DatasetFieldSplitAnyOfError;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfError.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfErrorAnyOf } from './datasetFieldSplitAnyOfErrorAnyOf';
+
+export type DatasetFieldSplitAnyOfError = DatasetFieldSplitAnyOfErrorAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfErrorAnyOf.ts

@@ -0,0 +1,6 @@
+import type { DatasetFieldSplitAnyOfErrorAnyOfCode } from './datasetFieldSplitAnyOfErrorAnyOfCode';
+
+export type DatasetFieldSplitAnyOfErrorAnyOf = {
+  code: DatasetFieldSplitAnyOfErrorAnyOfCode;
+  message: string;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfErrorAnyOfCode.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfErrorAnyOfCode = 'too_many_labels' | 'slice_failed';

package/openapi/gen/models/datasetFieldSplitAnyOfLastFill.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfLastFillAnyOf } from './datasetFieldSplitAnyOfLastFillAnyOf';
+
+export type DatasetFieldSplitAnyOfLastFill = DatasetFieldSplitAnyOfLastFillAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfLastFillAnyOf.ts

@@ -0,0 +1,7 @@
+import type { DatasetFieldSplitAnyOfLastFillAnyOfParts } from './datasetFieldSplitAnyOfLastFillAnyOfParts';
+
+export type DatasetFieldSplitAnyOfLastFillAnyOf = {
+  placed: number;
+  kept: number;
+  parts: DatasetFieldSplitAnyOfLastFillAnyOfParts;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfLastFillAnyOfParts.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfLastFillAnyOfParts = {[key: string]: number};

package/openapi/gen/models/datasetFieldSplitAnyOfPartsItem.ts

@@ -0,0 +1,6 @@
+import type { DatasetFieldSplitAnyOfPartsItemRolesItem } from './datasetFieldSplitAnyOfPartsItemRolesItem';
+
+export type DatasetFieldSplitAnyOfPartsItem = {
+  name: string;
+  roles: DatasetFieldSplitAnyOfPartsItemRolesItem[];
+};

package/openapi/gen/models/datasetFieldSplitAnyOfPartsItemRolesItem.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfPartsItemRolesItem = 'train' | 'validate' | 'test';

package/openapi/gen/models/datasetFieldSplitAnyOfProgress.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfProgressAnyOf } from './datasetFieldSplitAnyOfProgressAnyOf';
+
+export type DatasetFieldSplitAnyOfProgress = DatasetFieldSplitAnyOfProgressAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfProgressAnyOf.ts

@@ -0,0 +1,5 @@
+
+export type DatasetFieldSplitAnyOfProgressAnyOf = {
+  placed: number;
+  total: number;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfRecipe.ts

@@ -0,0 +1,3 @@
+import type { DatasetFieldSplitAnyOfRecipeAnyOf } from './datasetFieldSplitAnyOfRecipeAnyOf';
+
+export type DatasetFieldSplitAnyOfRecipe = DatasetFieldSplitAnyOfRecipeAnyOf | null;

package/openapi/gen/models/datasetFieldSplitAnyOfRecipeAnyOf.ts

@@ -0,0 +1,8 @@
+import type { DatasetFieldSplitAnyOfRecipeAnyOfSharesItem } from './datasetFieldSplitAnyOfRecipeAnyOfSharesItem';
+import type { DatasetFieldSplitAnyOfRecipeAnyOfBalanceByFieldId } from './datasetFieldSplitAnyOfRecipeAnyOfBalanceByFieldId';
+
+export type DatasetFieldSplitAnyOfRecipeAnyOf = {
+  shares: DatasetFieldSplitAnyOfRecipeAnyOfSharesItem[];
+  balanceByFieldId: DatasetFieldSplitAnyOfRecipeAnyOfBalanceByFieldId;
+  seed: number;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfRecipeAnyOfBalanceByFieldId.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfRecipeAnyOfBalanceByFieldId = string | null;

package/openapi/gen/models/datasetFieldSplitAnyOfRecipeAnyOfSharesItem.ts

@@ -0,0 +1,5 @@
+
+export type DatasetFieldSplitAnyOfRecipeAnyOfSharesItem = {
+  name: string;
+  share: number;
+};

package/openapi/gen/models/datasetFieldSplitAnyOfStatus.ts

@@ -0,0 +1,2 @@
+
+export type DatasetFieldSplitAnyOfStatus = 'filling' | 'ready' | 'failed';

package/openapi/gen/models/datasetSlice.ts

@@ -0,0 +1,18 @@
+import type { DatasetSliceItemFilter } from './datasetSliceItemFilter';
+import type { DatasetSliceFromSliceId } from './datasetSliceFromSliceId';
+import type { DatasetSliceStatus } from './datasetSliceStatus';
+import type { DatasetSliceError } from './datasetSliceError';
+
+export interface DatasetSlice {
+  id: string;
+  datasetId: string;
+  name: string;
+  itemFilter: DatasetSliceItemFilter;
+  frozenFieldIds: string[];
+  fromSliceId: DatasetSliceFromSliceId;
+  status: DatasetSliceStatus;
+  rows: number;
+  error: DatasetSliceError;
+  cutoff: string;
+  createdAt: string;
+}

package/openapi/gen/models/datasetSliceError.ts

@@ -0,0 +1,3 @@
+import type { DatasetSliceErrorAnyOf } from './datasetSliceErrorAnyOf';
+
+export type DatasetSliceError = DatasetSliceErrorAnyOf | null;

package/openapi/gen/models/datasetSliceErrorAnyOf.ts

@@ -0,0 +1,6 @@
+import type { DatasetSliceErrorAnyOfCode } from './datasetSliceErrorAnyOfCode';
+
+export type DatasetSliceErrorAnyOf = {
+  code: DatasetSliceErrorAnyOfCode;
+  message: string;
+};

package/openapi/gen/models/datasetSliceErrorAnyOfCode.ts

@@ -0,0 +1,2 @@
+
+export type DatasetSliceErrorAnyOfCode = 'no_rows' | 'cutoff_not_settled';

package/openapi/gen/models/datasetSliceFromSliceId.ts

@@ -0,0 +1,2 @@
+
+export type DatasetSliceFromSliceId = string | null;

package/openapi/gen/models/datasetSliceItemFilter.ts

@@ -0,0 +1,3 @@
+import type { DatasetSliceItemFilterAnyOf } from './datasetSliceItemFilterAnyOf';
+
+export type DatasetSliceItemFilter = DatasetSliceItemFilterAnyOf | null;

package/openapi/gen/models/datasetSliceItemFilterAnyOf.ts

@@ -0,0 +1,8 @@
+import type { DatasetSliceItemFilterAnyOfFieldValuesItem } from './datasetSliceItemFilterAnyOfFieldValuesItem';
+import type { DatasetSliceItemFilterAnyOfFieldSourcesItem } from './datasetSliceItemFilterAnyOfFieldSourcesItem';
+
+export type DatasetSliceItemFilterAnyOf = {
+  fieldValues?: DatasetSliceItemFilterAnyOfFieldValuesItem[];
+  fieldSources?: DatasetSliceItemFilterAnyOfFieldSourcesItem[];
+  missingRevisionFields?: string[];
+};

package/openapi/gen/models/datasetSliceItemFilterAnyOfFieldSourcesItem.ts

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

package/openapi/gen/models/datasetSliceItemFilterAnyOfFieldSourcesItemSourcesItem.ts

@@ -0,0 +1,4 @@
+import type { DatasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOf } from './datasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOf';
+import type { DatasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOfTwo } from './datasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOfTwo';
+
+export type DatasetSliceItemFilterAnyOfFieldSourcesItemSourcesItem = DatasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOf | DatasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOfTwo;

package/openapi/gen/models/datasetSliceItemFilterAnyOfFieldSourcesItemSourcesItemOneOf.ts

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