Datasets_RevertMerge
const url = 'https://junction-api.qualiastudios.dev/v1/accounts/example/datasets/example:revertMerge';const options = { method: 'POST', headers: {'X-API-Key': '<X-API-Key>', 'Content-Type': 'application/json'}, body: '{"name":"example","mergeEvent":"example"}'};
try { const response = await fetch(url, options); const data = await response.json(); console.log(data);} catch (error) { console.error(error);}curl --request POST \ --url https://junction-api.qualiastudios.dev/v1/accounts/example/datasets/example:revertMerge \ --header 'Content-Type: application/json' \ --header 'X-API-Key: <X-API-Key>' \ --data '{ "name": "example", "mergeEvent": "example" }'Always FAILED_PRECONDITION: a whole merge cannot be reverted. RemoveMergedDatasetMember returns an individual upload to standalone status. Kept until no client calls it.
Authorizations
Section titled āAuthorizations āParameters
Section titled ā Parameters āPath Parameters
Section titled āPath Parameters āThe account id.
The dataset id.
Request Body required
Section titled āRequest Body required āRequest for Datasets.RemapDatasetChannels.
object
Accounts/{account}/datasets/{dataset}
The DATASETS_MERGED event to reverse.
Example generated
{ "name": "example", "mergeEvent": "example"}Responses
Section titled ā Responses āOK
Response for Datasets.RevertMerge.
object
The merged dataset after the uploads were released. If its initial merge was reverted, its prior versions remain addressable by this resource name.
object
Accounts/{account}/datasets/{dataset}
Human name shown in the dashboard.
Free text about the dataset.
Upload, mixture or merged. Only MIXTURE can be created through CreateDataset; uploads arrive through the upload path and MERGED is made by MergeDatasets.
Where the dataset stands (the UI calls it status).
How far along the current status is, 0 to 1 (share of the upload landed while UPLOADING, share of episodes no longer waiting while REVIEWING).
Session labels. Editable on an upload and on a merged dataset, derived (the commonest value over what it reads, a merged datasetās own for the uploads it holds) on a mixture. A merged datasetās are its own: chosen when the merge makes it (an answer, else its uploadsā commonest), its collection tags seeded from its initial uploads and preserved on append. Every collection edit, including a compatibility method/axis edit, stays on the owner. Recording annotations on the uploadsā takes stay separate.
object
Task label, e.g. ārestock shelfā. Empty means unlabeled.
The robot label as recorded (a robot type key such as āopenarmā), or āumi-handheldā for handheld capture. Not the fleet robot; see source_robot.
Operator label (a name or a hashed id).
Legacy single-method value: teleop, vr, handheld, egocentric, policy_rollout, umi, policy-rollout, sim, or empty. An uploadās starts as its episodesā commonest.
Scene label, e.g. āshelfā.
Compatibility projection of Dataset.tags containing only the original six collection-method names, including saved axis aliases. Legacy method edits declare their human methods and positive axis aliases; existing saved independent axes and free names remain authoritative. Use typed axis paths or human_methods_only for independent edits.
Saved environment authority for derived real-world/sim tags. An axis edit changes only its pair; missing evidence does not prove real-world.
Saved origin authority for derived human/policy-rollout tags. Missing policy metadata never proves human-collected origin.
Saved controller authority for derived vr/gello tags. A controller does not establish teleoperation, and absence establishes no controller.
Accounts/{account}/robots/{robot}: the fleet robot the episodes were recorded on. Empty for handheld data or when unmapped. A robot, not a gripper design (a Robot of kind GRIPPER); it is not looked up when set. A merged datasetās uploads share one, chosen at the merge; changing it changes it on every upload it holds.
Accounts/{account}/robots/{robot}: the robot the episodes are played on. Set by default only on handheld uploads (method āhandheldā), to the accountās oldest robot (never a gripper design); empty otherwise until set. Changing it asks for no reach check; it closes the datasetās open out_of_reach issues, which were about the previous robot. Name a robot, not a gripper design (a Robot of kind GRIPPER): it is not looked up when set. Changing a merged datasetās changes it on every upload it holds; an upload merged away cannot be changed on its own.
Episode, time and standing counts.
object
Episodes in the dataset (for a mixture: in its resolved head).
Frames across every episode.
Recorded time across every episode, in seconds.
Episodes standing KEPT here.
Episodes standing UNREVIEWED here.
Episodes standing REJECTED here (validation rejects included).
Of those, rejected by ingest validation.
Open blocking issues in this datasetās scope, on the dataset itself or on episodes not rejected here.
Upload only, and set by GetDataset alone (it sums every file): the bytes of every file in its repository as published.
Upload only, and set by GetDataset alone: how many files those are.
Episodes a person ruled on here: those a personās keep or
reject in this datasetās scope (a merged datasetās: its uploadsā too)
stands on, a split takeās on each of its pieces without a ruling of
their own. An episode kept because nothing blocks it, and a validation
reject, are not counted. At most kept + rejected.
What stable and head resolve to.
object
The newest tag; unset when there is none yet.
object
The version tag it stands at, e.g. ā1.0ā; empty for head.
Content digest of the episode set, āb3:
Episodes in that set.
What the dataset yields now; always set.
object
The version tag it stands at, e.g. ā1.0ā; empty for head.
Content digest of the episode set, āb3:
Episodes in that set.
Head against the newest tag.
object
The tag measured from; empty when the dataset has no tag yet.
Episodes head yields that the tag does not.
Episodes the tag pins that head no longer yields.
Episodes in both whose pinned revision differs from headās (an edit: trim, subtasks, tags). Training reads exact revisions, so these count.
Robot interface and cameras.
object
Canonical robot-interface hash b3:<hex>; empty until derived.
Canonical state channel keys, e.g. āleft.joint.1ā, āright.ee.xā.
Canonical action channel keys.
Camera keys, e.g. ācontextā, āwrist_leftā.
Frames per second of the data rows.
Mixture only: the episodes it reads come from more than one interface.
Each state channel in vector order. A converted handheld uploadās are
the pair-frame channels its takes are sampled in. A merged datasetās are
its uploadsā (one entry per native channel, with sides where they
resolve it differently), on GetDataset only. Empty on a mixture, whose
uploads each place their channels their own way.
One state, action or camera channel of an upload: where it sits in the recording and the canonical key it resolves to.
object
Its position in the state or action vector: the n of the āstate[n]ā and āaction[n]ā keys Episodes.SampleEpisodeSeries returns. A cameraās is its place among the recordingās cameras.
The name the recording gives it, e.g. āleft_joint_1.posā.
The canonical key it resolves to, e.g. āleft.joint_1.posā;
āunmapped:
āradā, āmā or ānormā; empty when not known.
True when a personās channel mapping resolved it, not the name.
A merged datasetās state or action channel: each key its uploads
resolve it to, with the uploads that give it, when they do not agree
(a merged dataset made before its merge asked, or while a remap
settles). Empty when every upload gives canonical_key.
A camera (native_cameras): each key it is read as, with the uploads
that read it so. Always set on a merged datasetās or a mixtureās, even
where its uploads agree. On an uploadās, set only when the upload
reads one feature as two keys.
One canonical key some of a merged datasetās (or, for a camera, a mixtureās) uploads give a channel.
object
The canonical key, e.g. āgripper.posā.
Accounts/{account}/datasets/{dataset}: the uploads that give it.
Each action channel in vector order, as native_state_channels.
One state, action or camera channel of an upload: where it sits in the recording and the canonical key it resolves to.
object
Its position in the state or action vector: the n of the āstate[n]ā and āaction[n]ā keys Episodes.SampleEpisodeSeries returns. A cameraās is its place among the recordingās cameras.
The name the recording gives it, e.g. āleft_joint_1.posā.
The canonical key it resolves to, e.g. āleft.joint_1.posā;
āunmapped:
āradā, āmā or ānormā; empty when not known.
True when a personās channel mapping resolved it, not the name.
A merged datasetās state or action channel: each key its uploads
resolve it to, with the uploads that give it, when they do not agree
(a merged dataset made before its merge asked, or while a remap
settles). Empty when every upload gives canonical_key.
A camera (native_cameras): each key it is read as, with the uploads
that read it so. Always set on a merged datasetās or a mixtureās, even
where its uploads agree. On an uploadās, set only when the upload
reads one feature as two keys.
One canonical key some of a merged datasetās (or, for a camera, a mixtureās) uploads give a channel.
object
The canonical key, e.g. āgripper.posā.
Accounts/{account}/datasets/{dataset}: the uploads that give it.
Each recorded camera with the camera key it is read as: native_name is
the recordingās feature (e.g. āobservation.images.topā) and
canonical_key the key. A personās channel mapping can key a camera
otherwise than its name (āobservation.images.topā as ācam.overheadā).
An uploadās are its cameras in recording order; an entry without
sides binds the uploadās own episodes only. A merged datasetās or a
mixtureās are one per feature any upload it reads records, in the order
the first such upload places it, always with sides naming those
uploads, and canonical_key the commonest key. So an episode reads a
camera from the feature whose entry gives it that key for the episodeās
upload, and records the camera nowhere when no entry does. A version can
pin episodes of an upload the dataset no longer reads: no entry names
it, so its cameras are recorded nowhere.
One state, action or camera channel of an upload: where it sits in the recording and the canonical key it resolves to.
object
Its position in the state or action vector: the n of the āstate[n]ā and āaction[n]ā keys Episodes.SampleEpisodeSeries returns. A cameraās is its place among the recordingās cameras.
The name the recording gives it, e.g. āleft_joint_1.posā.
The canonical key it resolves to, e.g. āleft.joint_1.posā;
āunmapped:
āradā, āmā or ānormā; empty when not known.
True when a personās channel mapping resolved it, not the name.
A merged datasetās state or action channel: each key its uploads
resolve it to, with the uploads that give it, when they do not agree
(a merged dataset made before its merge asked, or while a remap
settles). Empty when every upload gives canonical_key.
A camera (native_cameras): each key it is read as, with the uploads
that read it so. Always set on a merged datasetās or a mixtureās, even
where its uploads agree. On an uploadās, set only when the upload
reads one feature as two keys.
One canonical key some of a merged datasetās (or, for a camera, a mixtureās) uploads give a channel.
object
The canonical key, e.g. āgripper.posā.
Accounts/{account}/datasets/{dataset}: the uploads that give it.
Lineage. Mixture: the uploads it reads at head, once each, an upload a merge took named by its merged dataset (once for all it holds). Merged: the uploads it holds, in the order they were merged. Upload: empty.
The mixtures that read this dataset directly: by name, or (for an
upload or a merged dataset) through a label source it matches. A Task
source is listed by the datasetās own Task; one that reads only takes
linked to it here is found by ListDatasetsā reads filter.
A signed midpoint poster from the first episode with one, in source and member order, searching the first 128 members per visible source. Empty when no poster can be delivered within that search.
Upload only: the repository it was published into (the git-native view).
Upload only: persisted ingest format.
Upload only: how the ingest ended.
Upload only: ā
Who created it (the uploader, or the person who made the mixture).
object
What kind of actor it is.
The personās user id when kind is PERSON; empty otherwise.
The personās display name at the time, for rendering without a lookup.
The rule code, or for a MODEL the Qualia model tier (e.g. āqualia-vlmā; āqualiaā for any other model), when not a person.
The run a model or rule finding came from, when it has one.
The API keyās id when a person acted through one; empty for a session. Never the key itself.
Signed identity evidence recorded with the change, kept apart from the principal above. Unset on older records and wherever none was signed.
object
How the principal authenticated.
The user id of a person verified as starting the work: the person of a session, or the person a trusted serviceās signed job record names. Empty when nobody was verified.
The initiatorās display name at the time, never their email.
The user id of the keyās creator at the time. Not who used the key.
Who owned the key at the time.
The owning spaceās id (a workspace or the organization) when
credential_owner is SPACE.
When the dataset was first published or created.
When anything about it last changed (a ruling, an issue, a source, a tag).
Sent back on UpdateDataset and DeleteDataset to guard against lost updates; a stale etag fails with ABORTED.
The name a training run cites (Version.reference = ā
Upload only, and only a handheld (UMI) upload whose state ingest placed in the pair frame: where its poses are. ROOT or TCP; unspecified for any other dataset. Read from the published repository (meta/ingest.toml and calibration.json), so it is filled by GetDataset alone: unset on ListDatasets, CreateDataset and UpdateDataset.
Upload only: the calibration the TCP poses were resolved with, as it was when they were. Set when poses_at is TCP, and then only by GetDataset. Compare it with a rigās calibration to tell whether that rigās calibration has been replaced since.
object
The uploaded fileās name, e.g. ātcp_calibration.jsonā.
When the calibration was made, āYYYY-MM-DDā: the leading date of the
fileās calibrated or else its derived text. Empty when the file gives
none.
Both hands, left then right.
One handās transform.
object
Which hand.
The TCPās pose in the trackerās frame: xyz in metres and rpy in radians (URDF convention, extrinsic XYZ), the fileās rotation matrix converted. A rotation whose pitch is within a hair of +-90 degrees has no unique roll and yaw; it is stored with roll 0.
object
X, y, z in metres.
Roll, pitch, yaw in radians.
The same TCP in the frame of the gripper designās ee_link for this
hand, in the form of tracker_to_tcp (so the same pitch limit). Display
only. Set with ee_link or not at all, and only when it composes with
the fileās controller_to_ee to the fileās controller_to_tcp, which is
what makes the TCP drawn the TCP used.
object
X, y, z in metres.
Roll, pitch, yaw in radians.
The link of the rigās gripper design that Hand.ee_to_tcp is a pose in,
with {side} for āleftā or ārightā (the gripper jointās convention in
RobotModel.Gripper), e.g. āopenarm_{side}_ee_base_linkā. Read from the
fileās own description of its end-effector frame. Empty when the file
names none, lacks the end-effector poses, or they disagree with its
controller_to_tcp (then no ee_to_tcp is set either). Display only.
ee_to_tcp is drawn in this linkās own frame, which must be the plain
end-effector frame the file means. An export whose link sits elsewhere
draws the TCP off by the difference: an OpenArm exported with the xacro
default collapse_internal_empty_links puts openarm_
Upload only, with poses_at: the key of the rig ingest recognised the
upload as recorded on (āumi-handheldā), which is the rig whose
calibration a ResolvePoses takes. Ingest decides it from the recorderās
robot_type, from the uploadās meta/ingest.toml [rig], or from the state
channel names, so it can name a rig when Episode.rig (for a LeRobot
upload only meta/info.jsonās robot_type) is empty or something else.
Filled by GetDataset alone, like poses_at.
Upload only: true when GetDataset could not read the uploadās repository for poses_at, poses_calibration and poses_rig, so they are unknown here and unspecified does not mean there are none. The rest of the dataset is answered as usual; read it again for the poses.
Upload only: the merged dataset that holds it, once it was merged into
one (MergeDatasets). Empty otherwise, including after member removal.
While held, it leaves the unfiltered ListDatasets; its reads
keep answering, by name and by slug (its versions, which keep resolving
as <slug>:<tag>, its takes, issues, ingest report and re-ingests), and
every write that names it, or an episode, issue or version under it, is
FAILED_PRECONDITION naming the merged dataset, through which it is
written.
Mixture only: the upload version it curates from, as accounts/{account}/datasets/{dataset}/versions/{tag}; set on create (CreateDataset) and never changed. Such a branch reads that upload as the version froze it, through one source pinned there: the uploadās rulings and blocking issues since reach neither it nor what reads it, its episodes read at the revisions the version pinned, its own keeps and rejects curate it, and edits are made in the upload. Empty for any other dataset.
How the datasetās reach check is walked, as the dataset stores it: what is unset follows the target robotās model (see Checks.GetReachStatus for what a RunCheck would use now). Saving it starts nothing.
object
The IK solver the dataset is solved with: always its target robotās, and set only on a status read (a runās resolved settings). A dataset does not pick one: a request that names a solver here (UpdateDataset, CreateDataset) is refused with INVALID_ARGUMENT (āa dataset uses its robotās solver; change it on the robotās Solver pageā), and a solver stored on a dataset before that is ignored. A robot with no solver cannot be solved on.
Where the takesā start sits from the relaxed grippersā midpoint, metres
in the robotās base frame (x forward, y left, z up): empty or exactly
three numbers, each finite and within 5 m either way. Empty follows the
target robot modelās reach_base, else 0, 0, 0. Stored to 0.1 mm and
applied to both hand paths as one rigid translation from the robotās home
hand midpoint.
Rotate both paired paths around world up before placing their first-row midpoint at the shared home reference. Radians; finite and within +/- pi. The robot base remains at world (0, 0, 0).
Where the source episodeās hand poses were recorded. Set by qds-api on reads; clients do not set it. TCP runs consume already-resolved TCP channels and never apply calibration again.
Digest of the TCP calibration already applied to the published upload, empty for root poses. Set by qds-api on reads.
Accounts/{account}/tasks/{task}: the Task an upload is recorded against, or empty when unlinked. A link, not a label: labels.task stays the text. Set on an upload (a task of its account, NOT_FOUND otherwise), or on a merged dataset, whose own it is (chosen when the merge makes it: an answer, else its uploadsā commonest; its uploads keep theirs); a mixture shows the commonest link of the uploads it reads (a merged datasetās own for the uploads it holds). Linking by label (LinkTaskLabels, and publishing a task) links an upload or a merged dataset by its own labels.task, never an upload a merge took. Deleting the task unlinks it. A mixture source can follow every episode linked to one task (Source.linked_task). Every take of an upload or a merged dataset with no link of its own reads the datasetās (Episode.linked_task_inherited): a merged datasetās takes read its own, not their uploadsā, so setting it links them all at once; UpdateDatasetRequest.relink_episodes moves the takes linked to the old one as well.
The revision of linked_task the link carries, and the one checks judge the datasetās takes against: the Taskās newest published revision when the link was made. 0 when unlinked, when the Task had no published revision then (its draft is judged), and on a mixture, which carries no link of its own. Publishing a newer revision leaves it, and starts no check; RelinkTask moves it to latest_task_revision and reruns.
Linked_taskās newest published revision, 0 when it has none (or nothing is linked, or on a mixture). Above linked_task_revision: the link has drifted, and RelinkTask would relink it.
Merged dataset only: member interfaces ready to freeze as one, and the uploads still awaiting or differing from the first memberās interface.
object
Number of merged members whose derived interfaces are settled.
Total number of uploads in the merged dataset.
Upload resource names whose interfaces are not settled yet.
The project that owns the dataset, empty when it is in the accountās default workspace. Gateway clients select it with X-Qualia-Workspace.
No longer set: a merge is final and a merged dataset is not corrected through its uploads. It was GetDatasetās merged membership for a member settings operation.
object
The merged dataset whose membership was confirmed.
Every upload it held, in merge order, including the selected upload.
Opaque merge/undo epoch from GetDataset; never recapture it on retry.
The datasetās editable etag; a member edit sends the selected uploadās.
The selected uploadās exact paired head. Empty on the merged datasetās context, which is used only to fence global label edits.
No longer set: a merged datasetās poses are not resolved through its uploads.
No longer set: a merged datasetās uploads were settled at the merge (one contract, one pose frame); interface_settlement is its view of an interface still re-deriving.
object
Number of merged members whose derived interfaces are settled.
Total number of uploads in the merged dataset.
Upload resource names whose interfaces are not settled yet.
No longer set, with settings_settlement.
GetDataset only: one per Task, by display name.
The Tasks this datasetās episodes are references of: a reference names its episode where it was recorded, or the merged dataset that upload went into, so a mixture has none. Deleting the dataset removes those references (the Tasks stay), so DeleteDataset refuses until it is sent with force.
object
Accounts/{account}/tasks/{task}
The Taskās display name.
How many of the datasetās episodes it references.
GetDataset only: how many distinct episodes those Tasks reference (an episode two Tasks reference counts once).
This datasetās tags: up to 64 nonblank strings of at most 256 bytes. Recognized collection names are teleop, vr, umi, egocentric, policy-rollout, sim, real-world, human and gello; they are ordered first in that order, followed by free tags in lexical order. Environment, origin, method and controller derive from saved metadata. The tags mask may echo unchanged classifications and edit custom strings only; use typed metadata masks for classification changes or Unknown. A merged dataset owns its metadata, which is never written to its uploads or replaced when uploads are appended. A mixture reads the tags of its sources. Distinct from episode curation and version tags.
GetDataset only, merged datasets: each uploadās progress toward its own recognized rigās CURRENT capture calibration. Independent of playback robot selection. A failed read is unknown, never a completed preparation.
object
Opaque ordered-membership epoch. Send it back on an explicit move or removal; a changed membership is ABORTED and must be confirmed again.
Number already at their current capture calibration.
Number of uploads in the current membership.
Preparation state for each upload, in membership order.
One uploadās current state. Names and reasons are suitable for the merged datasetās pre-check; no source data or historical rulings are removed.
object
The source upload resource.
The source uploadās display name.
The uploadās current preparation state.
Human-readable explanation when applicable.
UUID polled at this uploadās reingests/{operation_id} resource.
Recording rig, never an editable collection tag or playback robot.
The capture gripper supplying the calibration.
The capture calibrationās version.
Preparation is complete and its publication is pending; it cannot be cancelled.
False when none of these recordings has handheld poses to prepare.
Accounts/{account}/robots/{robot}: a Robot resource name, the UMI rigās gripper row (a Robot of kind GRIPPER with a rig kind). It is NOT the legacy accounts/{account}/rigs/{rig} Rig resource. The UMI rig this upload was composed with when it began: the gripper the uploader named, else the workspaceās one UMI rig. Recorded at publication, so a later edit or deletion of the rig does not change it. A copy in the same workspace carries it; a move to a workspace where the rig does not exist clears it (it is not listed among the robots cleared, and a move back does not restore it). Set by each uploadās publication from that uploadās own begin, empty included; a re-ingest, resolve or cut leaves it. Empty when no rig row composed the upload: it predates this field; it was uploaded by an SDK that sends no transfer session; the workspaceās rig was lent unasked and the tree kept its own TCP; it is a UMI recording only ingest recognises (channel names, a LeRobot robot_type); the merged dataset it appends to lent its membersā rig, which is their config, not a row; it was copied across workspaces; it was recorded on a robotās joints (see source_robot); or it is not an upload. Not set on a merged dataset or a mixture.
The rigs this datasetās uploads were recorded on, most uploads first; ties by resource name (a client that shows display names orders ties itself); the entry with no robot last whatever its count. An upload is recorded on one rig: a handheld (UMI) uploadās is the UMI rig that composed it (composed_umi_rig), and any other uploadās is its source_robot. A merged dataset lists the distinct rigs of the uploads it holds, and a mixture those of the uploads it read at its last resolve, each with how many were recorded on it. Computed when read, never stored, so it follows a robot assignment, an append, a memberās removal and a revert.
An upload with no rig is counted in the entry with no robot, never dropped. That is a handheld upload published before uploads recorded their rig, or whose latest upload composed none (a kept tree TCP, a rig lent by the merge target, an SDK that names no transfer session, a recording only ingest recognises as handheld), an upload copied across workspaces, and an upload of a robotās joints with no robot assigned.
A handheld upload never lists source_robot, which is a robot, not a gripper design. Known limit: a mergeās old āRecorded onā answer, and a source_robot written on a merged dataset, are written to every upload the dataset holds, and only arm uploads list it, so such a dataset lists one rig for arm uploads that may have been recorded on several.
One rig a datasetās uploads were recorded on: see Dataset.rigs.
object
Accounts/{account}/robots/{robot}: the rigās Robot (a UMI rigās gripper row, or the robot an arm upload was recorded on). A rig that no longer resolves to a robot is still named here. Empty counts the uploads whose rig was never recorded.
How many of the datasetās uploads were recorded on it.
Uploads released by this revert.
The EVENT_REVERTED event.
Example
{ "dataset": { "kind": "KIND_UNSPECIFIED", "state": "STATE_UNSPECIFIED", "labels": { "environment": "ENVIRONMENT_UNSPECIFIED", "origin": "ORIGIN_UNSPECIFIED", "teleopInput": "TELEOP_INPUT_UNSPECIFIED" }, "sourceFormat": "SOURCE_FORMAT_UNSPECIFIED", "verdict": "VERDICT_UNSPECIFIED", "creator": { "kind": "KIND_UNSPECIFIED", "attribution": { "authentication": "AUTHENTICATION_UNSPECIFIED", "credentialOwner": "CREDENTIAL_OWNER_UNSPECIFIED" } }, "posesAt": "POSES_AT_UNSPECIFIED", "posesCalibration": { "hands": [ { "side": "SIDE_UNSPECIFIED" } ] }, "reachSettings": { "solver": "SOLVER_UNSPECIFIED", "poseSource": "POSES_AT_UNSPECIFIED" }, "posePreparation": { "members": [ { "state": "STATE_UNSPECIFIED" } ] } }}default
Section titled ādefault āDefault error response
A refusal from the API itself.
object
The gRPC code name in upper case, e.g. NOT_FOUND.
Whether the same call may succeed if retried.
Empty, except when a dataset copy or move is refused: then one google.rpc.ErrorInfo with the refusalās reason code, its domain and, in metadata, the datasets it names.
object
A refusal from the gateway before the call reaches the API, for example 401 bad or missing API key, 403 key lacks the scope or environment closed, 413 body too large.
object
What went wrong.
Example generated
{ "code": "example", "message": "example", "retryable": true, "details": [ {} ]}