@eyepop.ai/eyepop 3.19.0 → 3.20.0

package/README.md

@@ -6,7 +6,7 @@ The EyePop.ai Node SDK provides JavaScript and TypeScript access to EyePop worke
 
 ### Node
 
-The SDK is tested with Node 20 LTS and newer.
+Requires Node.js 18 or newer. CI validates Node.js 22.
 
 ```shell
 npm install --save @eyepop.ai/eyepop

package/dist/eyepop.index.d.mts

@@ -95,11 +95,20 @@ interface Contour {
     points: Array<Point2d>;
     cutouts: Array<Array<Point2d>>;
 }
+/**
+ * A segmentation mask, optionally with a per-object point cloud.
+ *
+ * `world` is the base64 encoding of three little-endian float32 values per mask
+ * pixel, row-major, exactly width*height triples - so the point for bitmap
+ * pixel (i, j) is at triple index j * width + i. Points the worker could not
+ * place are NaN. Use decodePointCloud() to read it.
+ */
 interface Mask {
     bitmap: string;
     width: number;
     height: number;
     stride: number;
+    world?: string;
 }
 /**
  * A frame-level depth map as produced by depth estimation abilities
@@ -110,15 +119,35 @@ interface Mask {
  * source frame; map a source coordinate (x, y) to the map proportionally:
  * (x * width / source_width, y * height / source_height).
  *
- * Values are canonical metric depth (multiply by the camera's focal length
- * in pixels and divide by 300 for meters). Sky pixels carry +Infinity.
- * Use decodeDepthMap() to access the values.
+ * Sky pixels carry +Infinity. Use decodeDepthMap() to access the values.
+ *
+ * `semantic` says what the values mean, and is always present in prediction v2 -
+ * "unknown" included - so an absent member means a worker that predates the
+ * field rather than a map that declined to say:
+ *
+ * - "canonical_metric" - metres = value * focal_px / 300, with focal_px scaled
+ *   to the map's own resolution
+ * - "metric" - the value is already metres
+ * - "relative" - scale- AND shift-invariant, so ordering is meaningful but
+ *   distance is not. Not back-projectable: recovering a cloud from it yields a
+ *   distorted scene rather than a scaled one
+ * - "unknown" - the ability declared nothing. Not back-projectable
+ *
+ * `world` is the scene point cloud, present when the Pop asked for
+ * `depthMap.toWorld`. Same encoding as `Mask.world` - three little-endian
+ * float32 per pixel, row-major - but on this map's own grid, so the point for
+ * pixel (i, j) is at triple index j * width + i, exactly where that pixel's
+ * value sits in `values`. Points the worker could not place are NaN; the value
+ * at the same index is what says why, which is why both are sent.
  */
 interface Depth {
     width: number;
     height: number;
     values: string;
+    semantic?: DepthSemantic;
+    world?: string;
 }
+type DepthSemantic = 'canonical_metric' | 'metric' | 'relative' | 'unknown';
 interface PredictedObject extends PredictedClass {
     trackId?: number;
     x: number;
@@ -136,9 +165,29 @@ interface PredictedObject extends PredictedClass {
     keyPoints?: Array<PredictedKeyPoints>;
     details?: Array<Map<string, any>>;
 }
+/**
+ * A point in source pixels, optionally placed in 3D.
+ *
+ * `worldX`/`worldY`/`worldZ` are metres, present only when the pipeline was
+ * asked for world coordinates - a Pop with `depthMap` and a component with
+ * `toWorld` - and only in prediction v2. A point the worker could not place -
+ * sky, outside the depth map, no usable map - carries none of the three rather
+ * than a zero or a NaN, so test for undefined.
+ *
+ * Which frame they are in depends on the source's camera: with extrinsics, the
+ * world frame those define (Z up, ground at Z = 0); without them, the camera
+ * frame in the OpenCV convention (X right, Y down, Z forward from the camera).
+ *
+ * Only the carriers the worker enriches ever populate them: key points, outline
+ * points and contour points. Bounding boxes and mesh points do not - a box is
+ * not a point, and any single anchor choice would be arbitrary.
+ */
 interface Point2d {
     x: number;
     y: number;
+    worldX?: number;
+    worldY?: number;
+    worldZ?: number;
 }
 interface PredictedMesh {
     category?: string;
@@ -750,6 +799,111 @@ interface AliasResolution {
     model_uuid: string | null;
 }
 
+/**
+ * Camera calibration for a source, as accepted by the worker's setSource.
+ *
+ * A calibration is what turns a depth map into measurable world coordinates.
+ * Without one the worker falls back to an assumed horizontal field of view,
+ * which is a development scaffold rather than something to ship: for canonical
+ * metric depth the guess cancels out of X and Y and survives only in Z, so
+ * lateral measurements stay exact while every distance along the optical axis
+ * is wrong by however wrong the guess was.
+ *
+ * Mirrors what the instance API accepts. validateCamera() checks it locally so
+ * a bad calibration is an error here rather than a 400 halfway through an
+ * upload; the worker validates authoritatively, and the two are meant to agree.
+ */
+/**
+ * How far a rotation's norm may sit from 1 and still be taken for a rotation.
+ * Loose enough to survive a float round trip through JSON, tight enough to
+ * catch an un-normalised or garbage one. Matches the instance and the worker.
+ */
+declare const QUATERNION_TOLERANCE = 0.001;
+/**
+ * The pinhole parameters, normalised to the frame rather than given in pixels.
+ *
+ * Normalised so one calibration survives a resolution change: a camera
+ * calibrated at 1920x1080 and later streamed at 1280x720 keeps working. Pixel
+ * values carrying no calibration resolution are wrong by exactly the resolution
+ * ratio, and nothing downstream can detect it.
+ *
+ * `fx`/`fy` are the focal length as a fraction of the frame's width and height;
+ * `cx`/`cy` are the principal point in the same normalisation.
+ */
+interface CameraIntrinsics {
+    fx: number;
+    fy: number;
+    cx: number;
+    cy: number;
+}
+/** The OpenCV Brown-Conrady coefficients. All zero is a rectilinear lens. */
+interface CameraDistortion {
+    k1?: number;
+    k2?: number;
+    p1?: number;
+    p2?: number;
+    k3?: number;
+}
+/** A rotation, w first. Must be a unit quaternion. */
+interface Quaternion {
+    w: number;
+    x: number;
+    y: number;
+    z: number;
+}
+/** A translation in metres. */
+interface Vector3d {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * The camera's pose, expressed camera -> world.
+ *
+ * As `P_world = R(rotation) * P_camera + translation`, so the rotation carries
+ * the camera's axes onto the world's and the translation is where the camera
+ * itself sits. The world frame is Z up with the ground plane at Z = 0.
+ *
+ * This is the inverse of what cv2.solvePnP returns; a caller holding its
+ * rvec/tvec must invert both halves (R = R_cv.T, t = -R_cv.T @ t_cv), and t_cv
+ * is *not* the camera position.
+ *
+ * Left unset, the pose is the identity and world coordinates come back in the
+ * camera frame instead - OpenCV convention, X right, Y down, Z forward.
+ */
+interface CameraExtrinsics {
+    rotation?: Quaternion;
+    translation?: Vector3d;
+}
+/**
+ * One source's calibration.
+ *
+ * Exactly one of `intrinsics` and `hfovDegrees` describes the lens. Both is
+ * rejected rather than resolved by precedence - two descriptions of one lens
+ * that disagree have no right answer - and neither is rejected too, since
+ * defaulting a focal length would be inventing a lens.
+ *
+ * `hfovDegrees` is the shorthand for an operator who knows their lens's field
+ * of view but not its calibration matrix. It assumes square pixels and a
+ * centred principal point, so it approximates a real calibration rather than
+ * replacing one - but it describes the actual lens rather than the worker's
+ * assumed fallback. It composes with distortion and extrinsics exactly as
+ * intrinsics do.
+ */
+interface Camera {
+    intrinsics?: CameraIntrinsics;
+    hfovDegrees?: number;
+    distortion?: CameraDistortion;
+    extrinsics?: CameraExtrinsics;
+}
+/**
+ * Throw if the calibration cannot describe a real camera.
+ *
+ * Checked locally so a bad one fails before an upload starts rather than as a
+ * 400 partway through it. The rules are the worker's, not stricter ones.
+ */
+declare function validateCamera(camera: Camera): void;
+
 declare enum PredictionVersion {
     V1 = 1,
     V2 = 2
@@ -831,6 +985,23 @@ interface BaseComponent {
     type: PopComponentType;
     id?: number;
     forward?: PopForward;
+    /**
+     * Enrich this component's point based predictions with world coordinates,
+     * back-projected through the Pop's `depthMap`.
+     *
+     * Declared here because the instance declares it on one shared component
+     * type, but only a component that runs its own inference can honour it -
+     * inference and tracking - since that is what gives it an id for the worker
+     * to select on. Asking for it on a forward, contour finder or component
+     * finder is rejected when the Pop is compiled. A contour finder's points do
+     * get enriched, but they belong to the object that fed it, so the request
+     * goes on the inference component upstream.
+     *
+     * Enrichment needs a *metric* depth ability. A `relative` map is accepted
+     * and silently produces no world coordinates: its shift is unknown, so a
+     * cloud recovered from it would be distorted rather than merely unscaled.
+     */
+    toWorld?: boolean;
 }
 interface ForwardComponent extends BaseComponent {
 }
@@ -913,10 +1084,62 @@ interface ComponentFinderComponent extends BaseComponent {
     componentClassLabel?: string;
 }
 type PopComponent = ForwardComponent | InferenceComponent | TrackingComponent | ContourFinderComponent | ComponentFinderComponent;
+/**
+ * The depth ability whose frame level map feeds world coordinates.
+ *
+ * `ability` names it by alias and `abilityUuid` by uuid; give exactly one. A
+ * Pop has one depth map because the worker back-projects every prediction
+ * through it, so a second depth source would have nowhere to go. Naming one
+ * makes the converter build the depth branch itself and keep it out of the
+ * response - the caller asked for coordinates, not for a megabyte of base64
+ * depth per frame.
+ *
+ * `toWorld` back-projects the map itself, so the response carries a point cloud
+ * of the whole scene rather than one per segmented object. It is also what
+ * reveals the map: without it the injected branch stays out of the response
+ * entirely. Read the result with cloudOfDepth().
+ *
+ * Use a *metric* depth ability. A `relative` one is accepted and yields no
+ * world coordinates at all.
+ */
+interface PopDepthMap {
+    ability?: string;
+    abilityUuid?: string;
+    toWorld?: boolean;
+}
+/**
+ * Source level parameters a Pop applies to every source it processes, each
+ * overridable per source.
+ *
+ * Merged per field against whatever a source supplies, so a source giving its
+ * own roi but no camera keeps its roi and takes the default camera. Because the
+ * camera merges as one field, a source declaring its own lens replaces a
+ * defaulted one outright rather than mixing the two.
+ */
+interface SourceDefaults {
+    camera?: Camera;
+    roi?: Area;
+    fps?: string;
+    motionDetect?: boolean;
+    motionSensitivity?: number;
+    motionThreshold?: number;
+    motionGap?: number;
+    motionGridX?: number;
+    motionGridY?: number;
+}
 interface Pop {
     components: PopComponent[];
     postTransform?: string;
+    defaults?: SourceDefaults;
+    depthMap?: PopDepthMap;
 }
+/**
+ * Throw if a Pop cannot mean what it says.
+ *
+ * Only the parts a caller can get wrong locally: the worker rejects both of
+ * these too, but as a 400 once the Pop is already in flight.
+ */
+declare function validatePop(pop: Pop): void;
 interface MotionDetectConfig {
     motionDetect: boolean;
     motionSensitivity?: number;
@@ -936,6 +1159,16 @@ interface ProcessParams {
     motionDetect?: MotionDetectConfig | undefined;
     roi?: Area | undefined;
     fps?: string | undefined;
+    /**
+     * This source's camera calibration, overriding the Pop's `defaults.camera`.
+     *
+     * Without one the worker assumes a 60 degree horizontal field of view,
+     * which is a development scaffold: for canonical metric depth the guess
+     * cancels out of X and Y and survives only in Z, so lateral measurements
+     * stay exact while every distance along the optical axis is wrong by
+     * however wrong the guess was.
+     */
+    camera?: Camera | undefined;
 }
 interface ProcessRequest extends ProcessParams {
     source: Source;
@@ -1189,6 +1422,16 @@ declare class WorkerEndpoint extends Endpoint<WorkerEndpoint> {
      */
     process({ source, componentParams, motionDetect, roi }: ProcessRequest): Promise<ResultStream>;
     private processV1;
+    /**
+     * Reject a source's calibration before any work is started for it.
+     *
+     * Called by every entry point that takes ProcessParams rather than at the
+     * one boundary they share, because they have none: the group methods build
+     * their jobs directly instead of going through processV2. It runs before
+     * the concurrency limit is acquired, so a request that can never be sent
+     * does not hold a slot.
+     */
+    private validateProcessParams;
     private processV2;
     uploadGroup(paths: string[], params?: ProcessParams): Promise<ResultStream>;
     uploadStreamGroup(streams: Array<ReadableStream<Uint8Array> | Blob | BufferSource>, mimeTypes?: string[], params?: ProcessParams): Promise<ResultStream>;
@@ -1251,12 +1494,21 @@ declare class EvaluateDatasetJob {
     cancel(): void;
 }
 
+declare class EyePopDataWebSocketError extends Error {
+    readonly code = "DATA_WEBSOCKET_CONNECTION_FAILED";
+    readonly endpoint: string;
+    readonly sourceError: unknown;
+    constructor(url: string, event: unknown);
+}
 declare class DataEndpoint extends Endpoint<DataEndpoint> {
     private datasetApiUrl;
     private vlmApiUrl;
     private _accountId;
     private _ws;
     private _ws_current_reconnect_delay;
+    private _ws_reconnect_timeout;
+    private _ws_reconnect_enabled;
+    private _ws_connecting;
     private _account_event_handlers;
     private _dataset_uuid_to_event_handlers;
     constructor(options: DataOptions);
@@ -1264,6 +1516,9 @@ declare class DataEndpoint extends Endpoint<DataEndpoint> {
     disconnect(wait?: boolean): Promise<void>;
     protected reconnect(): Promise<DataEndpoint>;
     private reconnect_ws;
+    private open_ws;
+    private close_ws;
+    private schedule_ws_reconnect;
     private options;
     private request;
     listDatasets(include_stats?: boolean, modifiable_version_only?: boolean): Promise<Dataset[]>;
@@ -1373,6 +1628,123 @@ declare class DepthMap {
  */
 declare function decodeDepthMap(depth: Depth): DepthMap;
 
+/**
+ * Decoding and sampling of point clouds.
+ *
+ * When a pipeline is asked for world coordinates, an object carrying a
+ * segmentation mask also carries `mask.world`: three little-endian float32
+ * values per mask pixel, row-major, exactly width*height triples. The point for
+ * bitmap pixel (i, j) sits at triple index j * width + i, so the cloud indexes
+ * exactly like the bitmap with no separate lookup.
+ *
+ * A Pop asking for `depthMap.toWorld` also gets `depth.world`, the same
+ * encoding on the depth map's own grid: one point per map pixel rather than per
+ * mask pixel, covering the whole scene.
+ *
+ * Points the worker could not place are NaN - sky pixels, samples outside the
+ * depth map, and pixels the mask does not cover. NaN is the omission sentinel
+ * here, which is why this does not share decodeDepthMap()'s validation: that
+ * one rejects a payload of the wrong length, but nothing here may reject a NaN.
+ */
+
+/** Where a cloud's grid sits in the source frame, so at() can be reached from source pixels. */
+interface CloudBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+/**
+ * A decoded point cloud, per object or per scene.
+ *
+ * Create with decodePointCloud(), cloudOfObject(), cloudOfDepth() or
+ * cloudsOfPrediction(). Coordinates are metres, in the frame the source's
+ * camera extrinsics define (Z up, ground at Z = 0) or the OpenCV camera frame
+ * when it supplied none.
+ *
+ * The grid is whatever the cloud was made from: an object's mask, which spans
+ * its bounding box rather than the frame, or the depth map itself, which spans
+ * the whole frame. Either way (i, j) is a source coordinate only via that box,
+ * which cloudOfObject() and cloudOfDepth() record - so atSource() needs one of
+ * those two.
+ */
+declare class PointCloud {
+    readonly width: number;
+    readonly height: number;
+    /** xyz per pixel, row-major; an omitted point is NaN in all three. */
+    readonly points: Float32Array;
+    private readonly box;
+    constructor(width: number, height: number, points: Float32Array, box?: CloudBox);
+    /**
+     * The world point for pixel (i, j), or undefined where the worker placed none.
+     *
+     * (i, j) indexes the cloud's own grid - the mask bitmap, or the depth map
+     * for a scene cloud: i is the column, j is the row.
+     */
+    at(i: number, j: number): Vector3 | undefined;
+    /**
+     * The world point for a source frame coordinate inside the cloud's box.
+     *
+     * Needs a cloud built with cloudOfObject(), or with cloudOfDepth() and the
+     * frame size: the grid covers a box, and nothing else knows where it sits.
+     */
+    atSource(x: number, y: number): Vector3 | undefined;
+    isPlaced(i: number, j: number): boolean;
+    /**
+     * Just the points the worker placed.
+     *
+     * The shape a scatter plot or an export wants: the grid with its NaN holes
+     * dropped, and no mask to apply first.
+     */
+    get placedPoints(): Vector3[];
+    /**
+     * Per axis (min, max) in metres over the placed points, or undefined if none were.
+     *
+     * The counterpart to DepthMap's finiteMin/finiteMax, which are one axis
+     * because a depth map has one value per pixel.
+     */
+    get bounds(): CloudBounds | undefined;
+}
+interface Vector3 {
+    x: number;
+    y: number;
+    z: number;
+}
+interface CloudBounds {
+    min: Vector3;
+    max: Vector3;
+}
+/** A mask's point cloud, or undefined if it carries none. */
+declare function decodePointCloud(mask: Mask | undefined, box?: CloudBox): PointCloud | undefined;
+/**
+ * The point cloud of a predicted object's mask, or undefined if it has none.
+ *
+ * Records the object's bounding box, so atSource() works.
+ */
+declare function cloudOfObject(obj: PredictedObject | undefined): PointCloud | undefined;
+/**
+ * The scene point cloud of a frame level depth map, or undefined if it has none.
+ *
+ * Present when the Pop asked for `depthMap.toWorld`. Unlike a mask cloud this
+ * one spans the whole frame, so its grid is the depth map's rather than an
+ * object's bounding box - and at(i, j) indexes map pixels, the same index that
+ * pixel's value sits at in `depth.values`.
+ *
+ * Pass the prediction's source_width/source_height to enable atSource(); the
+ * frame is the box in this case.
+ */
+declare function cloudOfDepth(depth: Depth | undefined, sourceWidth?: number, sourceHeight?: number): PointCloud | undefined;
+/**
+ * Every point cloud in a prediction, outermost object first.
+ *
+ * An array rather than a single value like decodeDepthMap(), because a cloud
+ * belongs to one object's mask and a prediction carries as many as it has
+ * masked objects. Nested objects are included. A scene cloud, if the Pop asked
+ * for one, comes last - appended rather than inserted so an existing index into
+ * the object clouds keeps meaning what it did.
+ */
+declare function cloudsOfPrediction(prediction: Prediction | undefined): PointCloud[];
+
 type Bytes = string | ArrayBuffer | Uint8Array | Buffer | null | undefined;
 interface StreamEvent {
     type: string;
@@ -1551,4 +1923,4 @@ declare namespace EyePop {
     function dataEndpoint(opts?: DataOptions): DataEndpoint;
 }
 
-export { type AbilityAliasEntry, AbstractJob, type AccessTokenAuth, type AliasResolution, type Annotation, AnnotationInclusionMode, AnnotationType, type ApiKeyAuth, type Area, AreaType, ArtifactType, type Asset, type AssetImport, AssetInclusionMode, AssetStatus, AssetUrlType, type AssetUuidSource, type Auth0Options, type Authentication, type AutoAnnotate, type AutoAnnotateParams, type AutoAnnotatePrompt, AutoAnnotateStatus, AutoAnnotateTask, type AutoPromptConfig, type AutoTask, type BaseArea, type BaseComponent, type BaseTask, type Box, type ChangeEvent, ChangeType, type ClassificationTask, type ComponentFinderComponent, type ComponentParams, type Contour, type ContourArea, type ContourFinderComponent, ContourType, type CreateWorkflow, type CreateWorkflowConfig, DEFAULT_PREDICTION_VERSION, DataApiType, DataEndpoint, type DataOptions, type DataSession, type Dataset, type DatasetAutoAnnotate, type DatasetAutoAnnotateCreate, type DatasetAutoAnnotateUpdate, type DatasetCreate, type DatasetHeroAssetUpdate, type DatasetParent, type DatasetUpdate, type DatasetVersion, type DatasetVersionAssetStats, type Depth, DepthMap, type DownloadResponse, Endpoint, EndpointState, type EvaluateConfig, type EvaluateFilter, type EvaluateRequest, type EvaluateResponse, type EvaluateRunInfo, EvaluationStatus, ExportedBy, EyePop, EyepopLineDecoder, type FileSource, type ForwardComponent, ForwardOperatorType, type HttpClient, type InferRequest, type InferRunInfo, type InferRuntimeConfig, type InferenceComponent, InferenceType, type ListWorkFlowItem, type ListWorkFlowItemMetadata, type ListWorkflowItemMetadataLabels, LoadFromAssetUuidJob, LoadFromGroupJob, LoadFromJob, LoadMediaStreamJob, type LocalAuth, type Mask, type MediaStreamSource, type Model, type ModelCreate, type ModelExport, ModelExportStatus, ModelFormat, type ModelMetrics, ModelPrecisionType, type ModelSample, ModelStatus, ModelTask, type ModelTrainingProgress, ModelTrainingStage, ModelType, type ModelUpdate, type MotionDetectConfig, MotionModel, type MultipartContent, type MultipartPart, type OAuth2Auth, type OnChangeEvent, type Options, type PathSource, type PlatformSupport, type Point2d, type Point3d, type Pop, type PopComponent, PopComponentType, type PopCrop, type PopForward, type PopForwardOperator, type PredictedClass, type PredictedEmbedding, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedMotion, type PredictedObject, type PredictedText, type Prediction, PredictionVersion, type ProcessParams, type ProcessRequest, type QcAiHubExportParams, type RectangleArea, type ResultStream, type Roi, Semaphore, type Session, type SessionAuth, type Source, Stream, type StreamEvent, type StreamSource, type StreamTime, TaskMode, TaskType, type TimeSpan, type TrackingComponent, TranscodeMode, type TransformInto, TransientPopId, UploadGroupJob, UploadJob, type UploadSource, type UrlSource, UserReview, VideoMode, type VlmAbility, type VlmAbilityCreate, type VlmAbilityGroup, type VlmAbilityGroupCreate, type VlmAbilityGroupUpdate, VlmAbilityStatus, type VlmAbilityUpdate, WebrtcBase, WebrtcWhep, WebrtcWhip, WorkerEndpoint, type WorkerOptions, type WorkerSession, type Workflow, WorkflowPhase, accessTokenCredential, apiKeyCredential, decodeDepthMap, EyePop as default, encodeMultipartFormData, getBaseUrl, randomMultipartBoundary, readableStreamFromString, resolveAuth };
+export { type AbilityAliasEntry, AbstractJob, type AccessTokenAuth, type AliasResolution, type Annotation, AnnotationInclusionMode, AnnotationType, type ApiKeyAuth, type Area, AreaType, ArtifactType, type Asset, type AssetImport, AssetInclusionMode, AssetStatus, AssetUrlType, type AssetUuidSource, type Auth0Options, type Authentication, type AutoAnnotate, type AutoAnnotateParams, type AutoAnnotatePrompt, AutoAnnotateStatus, AutoAnnotateTask, type AutoPromptConfig, type AutoTask, type BaseArea, type BaseComponent, type BaseTask, type Box, type Camera, type CameraDistortion, type CameraExtrinsics, type CameraIntrinsics, type ChangeEvent, ChangeType, type ClassificationTask, type CloudBounds, type CloudBox, type ComponentFinderComponent, type ComponentParams, type Contour, type ContourArea, type ContourFinderComponent, ContourType, type CreateWorkflow, type CreateWorkflowConfig, DEFAULT_PREDICTION_VERSION, DataApiType, DataEndpoint, type DataOptions, type DataSession, type Dataset, type DatasetAutoAnnotate, type DatasetAutoAnnotateCreate, type DatasetAutoAnnotateUpdate, type DatasetCreate, type DatasetHeroAssetUpdate, type DatasetParent, type DatasetUpdate, type DatasetVersion, type DatasetVersionAssetStats, type Depth, DepthMap, type DepthSemantic, type DownloadResponse, Endpoint, EndpointState, type EvaluateConfig, type EvaluateFilter, type EvaluateRequest, type EvaluateResponse, type EvaluateRunInfo, EvaluationStatus, ExportedBy, EyePop, EyePopDataWebSocketError, EyepopLineDecoder, type FileSource, type ForwardComponent, ForwardOperatorType, type HttpClient, type InferRequest, type InferRunInfo, type InferRuntimeConfig, type InferenceComponent, InferenceType, type ListWorkFlowItem, type ListWorkFlowItemMetadata, type ListWorkflowItemMetadataLabels, LoadFromAssetUuidJob, LoadFromGroupJob, LoadFromJob, LoadMediaStreamJob, type LocalAuth, type Mask, type MediaStreamSource, type Model, type ModelCreate, type ModelExport, ModelExportStatus, ModelFormat, type ModelMetrics, ModelPrecisionType, type ModelSample, ModelStatus, ModelTask, type ModelTrainingProgress, ModelTrainingStage, ModelType, type ModelUpdate, type MotionDetectConfig, MotionModel, type MultipartContent, type MultipartPart, type OAuth2Auth, type OnChangeEvent, type Options, type PathSource, type PlatformSupport, type Point2d, type Point3d, PointCloud, type Pop, type PopComponent, PopComponentType, type PopCrop, type PopDepthMap, type PopForward, type PopForwardOperator, type PredictedClass, type PredictedEmbedding, type PredictedKeyPoint, type PredictedKeyPoints, type PredictedMesh, type PredictedMotion, type PredictedObject, type PredictedText, type Prediction, PredictionVersion, type ProcessParams, type ProcessRequest, QUATERNION_TOLERANCE, type QcAiHubExportParams, type Quaternion, type RectangleArea, type ResultStream, type Roi, Semaphore, type Session, type SessionAuth, type Source, type SourceDefaults, Stream, type StreamEvent, type StreamSource, type StreamTime, TaskMode, TaskType, type TimeSpan, type TrackingComponent, TranscodeMode, type TransformInto, TransientPopId, UploadGroupJob, UploadJob, type UploadSource, type UrlSource, UserReview, type Vector3, type Vector3d, VideoMode, type VlmAbility, type VlmAbilityCreate, type VlmAbilityGroup, type VlmAbilityGroupCreate, type VlmAbilityGroupUpdate, VlmAbilityStatus, type VlmAbilityUpdate, WebrtcBase, WebrtcWhep, WebrtcWhip, WorkerEndpoint, type WorkerOptions, type WorkerSession, type Workflow, WorkflowPhase, accessTokenCredential, apiKeyCredential, cloudOfDepth, cloudOfObject, cloudsOfPrediction, decodeDepthMap, decodePointCloud, EyePop as default, encodeMultipartFormData, getBaseUrl, randomMultipartBoundary, readableStreamFromString, resolveAuth, validateCamera, validatePop };