@formant/data-sdk 1.80.6 → 1.80.8

package/dist/types/data-sdk/src/connector/model/IUniverseData.d.ts

@@ -0,0 +1,124 @@
+import { IBitset } from "../../model/IBitset";
+import { IJointState } from "../../model/IJointState";
+import { ILocation } from "../../model/ILocation";
+import { IMarker3DArray } from "../../model/IMarker3DArray";
+import { INumericSetEntry } from "../../model/INumericSetEntry";
+import { ITransformNode } from "../../model/ITransformNode";
+import { StreamType } from "../../model/StreamType";
+import { IPose } from "./IPose";
+import { IUniverseGridMap } from "./IUniverseGridMap";
+import { IUniverseOdometry } from "./IUniverseOdometry";
+import { IUniversePath } from "./IUniversePath";
+import { IUniversePointCloud } from "./IUniversePointCloud";
+export type DataSourceState = "missing_data" | "connected" | "disconnected" | "connecting" | "disconnecting";
+export declare const NoData: unique symbol;
+export declare const LoadingData: unique symbol;
+export declare const FailedData: unique symbol;
+export type DataStatus = Symbol;
+export type RtcStreamType = "ping" | "pong" | "stream-control" | "streams-info" | "agent-info" | "numeric" | "boolean" | "bitset" | "twist" | "compressed-image" | "h264-video-frame" | "audio-chunk" | "pose" | "goal-id" | "joint-state" | "pose-with-covariance" | "point-cloud" | "marker-array" | "point" | "json-string";
+export type CloseSubscription = () => void;
+export interface UniverseRosDataSource {
+    id: string;
+    sourceType: "realtime";
+    rosTopicName: string;
+    rosTopicType: string;
+}
+export interface UniverseHardwareDataSource {
+    id: string;
+    sourceType: "hardware";
+    rtcStreamName: string;
+}
+export interface UniverseTelemetrySource {
+    id: string;
+    sourceType: "telemetry";
+    streamName: string;
+    streamType?: StreamType;
+    latestDataPoint?: boolean;
+}
+export type UniverseDataSource = UniverseRosDataSource | UniverseTelemetrySource | UniverseHardwareDataSource;
+export interface ITelemetryStream {
+    name: string;
+    disabled?: boolean;
+    validation?: {
+        schemaId: string;
+    };
+    configuration: {
+        type: string;
+        mapTopic?: string;
+    };
+}
+export interface ITelemetryRosStream {
+    topicName: string;
+    topicType: string;
+}
+export interface IRealtimeStream {
+    rtcStreamType: RtcStreamType;
+    name: string;
+}
+export interface IUniverseStatistics {
+    rtcDevices: {
+        deviceId: string;
+        deviceName: string;
+        totalRtcDataBytes: number;
+    }[];
+}
+export interface Interaction {
+    deviceId: string;
+    id: string;
+    name: string;
+    description: string;
+    icon: string;
+}
+export interface RealtimeButtonConfiguration {
+    streamName: string;
+}
+export interface IUniverseData {
+    addInteraction: (interaction: Interaction) => void;
+    removeInteraction: (id: string) => void;
+    getInteractions: () => Interaction[];
+    addInteractionsChangedListener: (callback: (interactions: Interaction[]) => void) => () => void;
+    addInteractionListener: (callback: (interaction: Interaction) => void) => () => void;
+    setTime(time: Date | "live"): void;
+    getTime(): Date | "live";
+    getTimeMs(): number;
+    getLatestTransformTrees(deviceId: string): Promise<{
+        streamName: string;
+        transformTree: ITransformNode;
+    }[]>;
+    getLatestLocations(deviceId: string): Promise<{
+        streamName: string;
+        location: ILocation;
+    }[]>;
+    getDeviceContexts(): Promise<{
+        deviceName: string;
+        deviceId: string;
+    }[]>;
+    getDeviceContextName(deviceId: string): Promise<string | undefined>;
+    getTelemetryStreamType(deviceId: string, streamName: string): Promise<string | undefined>;
+    getTelemetryStreams(deviceId: string): Promise<ITelemetryStream[]>;
+    getTeleopRosStreams(deviceId: string): Promise<ITelemetryRosStream[]>;
+    getUrdfs(deviceId: string): Promise<string[]>;
+    getHardwareStreams(deviceId: string): Promise<IRealtimeStream[]>;
+    subscribeToBitset(deviceId: string, source: UniverseDataSource, callback: (data: IBitset | DataStatus) => void): CloseSubscription;
+    subscribeToPointCloud(deviceId: string, source: UniverseDataSource, callback: (data: IUniversePointCloud | DataStatus) => void): CloseSubscription;
+    subscribeToOdometry(deviceId: string, source: UniverseDataSource, callback: (data: IUniverseOdometry | DataStatus) => void, trail?: number): CloseSubscription;
+    subscribeToPath(deviceId: string, source: UniverseDataSource, callback: (data: IUniversePath | DataStatus) => void): CloseSubscription;
+    subscribeToPose(deviceId: string, source: UniverseDataSource, callback: (data: IPose | DataStatus) => void): CloseSubscription;
+    subscribeToGeometry(deviceId: string, source: UniverseDataSource, callback: (data: IMarker3DArray | DataStatus) => void): CloseSubscription;
+    subscribeToJointState(deviceId: string, source: UniverseDataSource, callback: (data: IJointState | DataStatus) => void): CloseSubscription;
+    subscribeToGridMap(deviceId: string, source: UniverseDataSource, callback: (data: IUniverseGridMap | DataStatus) => void): CloseSubscription;
+    subscribeToVideo(deviceId: string, source: UniverseDataSource, callback: (frame: HTMLCanvasElement | DataStatus) => void): CloseSubscription;
+    subscribeToTransformTree(deviceId: string, source: UniverseDataSource, callback: (data: ITransformNode | DataStatus) => void): CloseSubscription;
+    subscribeToLocation(deviceId: string, source: UniverseDataSource, callback: (data: ILocation | DataStatus) => void): CloseSubscription;
+    subscribeToJson<T>(deviceId: string, source: UniverseDataSource, callback: (data: T | DataStatus) => void): CloseSubscription;
+    subscribeToText(deviceId: string, source: UniverseDataSource, callback: (text: string | DataStatus) => void): CloseSubscription;
+    subscribeToNumeric(deviceId: string, source: UniverseDataSource, callback: (num: [number, number][] | DataStatus) => void): CloseSubscription;
+    subscribeToNumericSet(deviceId: string, source: UniverseDataSource, callback: (entry: [number, INumericSetEntry[]][] | DataStatus) => void): CloseSubscription;
+    getStatistics(): Promise<IUniverseStatistics>;
+    subscribeDataSourceStateChange(deviceId: string, source: UniverseDataSource, onDataSourceStateChange?: (state: DataSourceState | DataStatus) => void): CloseSubscription;
+    subscribeToImage(deviceId: string, source: UniverseDataSource, callback: (image: HTMLCanvasElement | DataStatus) => void): CloseSubscription;
+    sendRealtimePose(deviceId: string, streamName: string, pose: IPose): Promise<void>;
+    sendRealtimeBoolean(deviceId: string, streamName: string, value: boolean): Promise<void>;
+    sendRealtimeBitset(deviceId: string, streamName: string, bitset: IBitset): Promise<void>;
+    sendCommand(deviceId: string, name: string, data?: string): Promise<void>;
+}

package/dist/types/data-sdk/src/connector/model/IUniverseGridMap.d.ts

@@ -0,0 +1,11 @@
+import { ITransform } from "../../model/ITransform";
+export interface IUniverseGridMap {
+    worldToLocal?: ITransform;
+    width: number;
+    height: number;
+    resolution: number;
+    origin: ITransform;
+    url?: string;
+    data?: number[];
+    alpha?: number[];
+}

package/dist/types/data-sdk/src/connector/model/IUniverseOdometry.d.ts

@@ -0,0 +1,6 @@
+import { IPoseWithCovariance } from "../../model/IPoseWithCovariance";
+import { ITransform } from "../../model/ITransform";
+export interface IUniverseOdometry extends IPoseWithCovariance {
+    worldToLocal?: ITransform;
+    trail?: [number, ITransform][];
+}

package/dist/types/data-sdk/src/connector/model/IUniversePath.d.ts

@@ -0,0 +1,3 @@
+import { IPath } from "../../model/IPath";
+export interface IUniversePath extends IPath {
+}

package/dist/types/data-sdk/src/connector/model/IUniversePointCloud.d.ts

@@ -0,0 +1,6 @@
+import { ITransform } from "../../model/ITransform";
+import { IPcd } from "./IPcd";
+export interface IUniversePointCloud {
+    pcd?: IPcd;
+    worldToLocal?: ITransform;
+}

package/dist/types/data-sdk/src/devices/BaseDevice.d.ts

@@ -0,0 +1,47 @@
+import { IRtcSendConfiguration, IRtcStreamMessage, RtcClient, IRtcPeer } from "@formant/realtime-sdk";
+import { IPingInfo } from "@formant/realtime-sdk/dist/rtc-client/models/IPingInfo";
+import { DataChannel } from "../DataChannel";
+import { EventEmitter } from "eventemitter3";
+import { Manipulator } from "../Manipulator";
+import { BinaryRequestDataChannel, TextRequestDataChannel } from "../RequestDataChannel";
+import { IRealtimeSubscriber } from "./IRealtimeSubscriber";
+import { ICustomDataChannelCreator } from "./ICustomDataChannelCreator";
+import { ConfigurationDocument, RealtimeListener, RealtimeAudioStream, RealtimeVideoStream, RealtimeDataStream } from "./device.types";
+import { TelemetryResult } from "../model/TelemetryResult";
+import { IEventQuery } from "../model/IEventQuery";
+import { IEvent } from "../model/IEvent";
+export declare abstract class BaseDevice extends EventEmitter implements IRealtimeSubscriber, ICustomDataChannelCreator {
+    rtcClient: RtcClient | undefined;
+    remoteDevicePeerId: string | null;
+    protected realtimeListeners: RealtimeListener[];
+    protected connectionMonitorInterval: ReturnType<typeof setInterval> | undefined;
+    abstract getConfiguration(): Promise<ConfigurationDocument>;
+    abstract startRealtimeConnection(sessionType?: number): Promise<void>;
+    abstract getRemotePeer(): Promise<IRtcPeer>;
+    abstract getTelemetry(streamNameOrStreamNames: string | string[], start: Date, end: Date, tags?: {
+        [key in string]: string[];
+    }, limit?: number, offset?: number, latestOnly?: boolean): Promise<TelemetryResult[]>;
+    abstract queryEvents(query: IEventQuery): Promise<IEvent[]>;
+    protected handleMessage: (peerId: string, message: any) => void;
+    protected stopConnectionMonitoring(): void;
+    protected assertNotCancelled(cancelled: boolean): void;
+    getRealtimeStatus(): "disconnected" | "connecting" | "connected";
+    getRealtimePingInfo(): IPingInfo | undefined;
+    getRealtimePing(): number | undefined;
+    addRealtimeListener(listener: RealtimeListener): void;
+    removeRealtimeListener(listener: RealtimeListener): void;
+    getRealtimeManipulators(): Promise<Manipulator[]>;
+    getRealtimeVideoStreams(): Promise<RealtimeVideoStream[]>;
+    createCustomRequestDataChannel(channelName: string, timeout?: number): TextRequestDataChannel;
+    createCustomBinaryRequestDataChannel(channelName: string, timeout?: number): BinaryRequestDataChannel;
+    startListeningToRealtimeVideo(stream: RealtimeVideoStream): Promise<void>;
+    stopListeningToRealtimeVideo(stream: RealtimeVideoStream): Promise<void>;
+    startListeningToRealtimeDataStream(stream: RealtimeDataStream): Promise<void>;
+    stopListeningToRealtimeDataStream(stream: RealtimeDataStream): Promise<void>;
+    enableRealtimeTelemetryPriorityIngestion(streamName: string): Promise<void>;
+    disableRealtimeTelemetryPriorityIngestion(streamName: string): Promise<void>;
+    changeStreamAudioType(streamName: string, newFormat: "wav" | "opus"): Promise<void>;
+    createCustomDataChannel(channelName: string, rtcConfig?: RTCDataChannelInit): Promise<DataChannel>;
+    sendRealtimeMessage(message: IRtcStreamMessage, config?: IRtcSendConfiguration): Promise<void>;
+    getRealtimeAudioStreams(): Promise<RealtimeAudioStream[]>;
+}

package/dist/types/data-sdk/src/devices/Device.d.ts

@@ -0,0 +1,88 @@
+import { IRtcPeer } from "@formant/realtime-sdk";
+import { createDevice } from "../api/createDevice";
+import { disableDevice } from "../api/disableDevice";
+import { getDevicesData } from "../api/getDevicesData";
+import { patchDevice } from "../api/patchDevice";
+import { queryDevicesData } from "../api/queryDevicesData";
+import { CaptureStream } from "../CaptureStream";
+import { AggregateLevel } from "../model/AggregateLevel";
+import { EventType } from "../model/EventType";
+import { IEvent } from "../model/IEvent";
+import { IEventQuery } from "../model/IEventQuery";
+import { IInterventionResponse } from "../model/IInterventionResponse";
+import { IInterventionTypeMap } from "../model/IInterventionTypeMap";
+import { InterventionType } from "../model/InterventionType";
+import { IShare } from "../model/IShare";
+import { ITags } from "../model/ITags";
+import { SessionType } from "../model/SessionType";
+import { TelemetryResult } from "../model/TelemetryResult";
+import { BaseDevice } from "./BaseDevice";
+import { ConfigurationDocument, ICommandTemplate, IStartRealtimeConnectionOptions, TelemetryStream } from "./device.types";
+export declare class Device extends BaseDevice {
+    id: string;
+    name: string;
+    private organizationId;
+    tags?: ITags | undefined;
+    constructor(id: string, name: string, organizationId: string, tags?: ITags | undefined);
+    static createDevice: typeof createDevice;
+    static patchDevice: typeof patchDevice;
+    static getDevicesData: typeof getDevicesData;
+    static queryDevicesData: typeof queryDevicesData;
+    static disableDevice: typeof disableDevice;
+    getLatestTelemetry(): Promise<any>;
+    /**
+     * Asynchronously retrieves the configuration document for a device.
+     *
+     * @param {boolean} getDesiredConfigurationVersion - Whether to retrieve the desired configuration version
+     * @returns {Promise<ConfigurationDocument>} A promise that resolves to the configuration document
+     * @throws {Error} Throws an error if the device has no configuration or has never been turned on
+     */
+    getConfiguration(getDesiredConfigurationVersion?: boolean): Promise<ConfigurationDocument>;
+    /**
+     * Asynchronously retrieves the device's agent version string
+     *
+     * @returns {Promise<string | undefined | null>} A promise that resolves to the agent version
+     * @throws {Error} Throws an error if the device info cannot be fetched
+     */
+    getAgentVersion(): Promise<string | undefined | null>;
+    getFileUrl(fileId: string): Promise<string[]>;
+    /**
+     * Starts a real-time connection with the remote device using WebRTC.
+     * @param {number} [options] - Optional session type to be used for the connection.
+     * @throws `Error`  If the connection could not be established or if a connection already exists.
+     * @returns {void}
+     */
+    startRealtimeConnection(options?: SessionType | IStartRealtimeConnectionOptions): Promise<void>;
+    private getRemoteDevicePeerId;
+    private initConnectionMonitoring;
+    getRemotePeer(): Promise<IRtcPeer>;
+    stopRealtimeConnection(): Promise<void>;
+    isInRealtimeSession(): Promise<boolean>;
+    getAvailableCommands(includeDisabled?: boolean): Promise<ICommandTemplate[]>;
+    sendCommand(name: string, data?: string, time?: Date, metadata?: {}, id?: string): Promise<Response>;
+    getCommand(id: string): Promise<Response>;
+    createCaptureStream(streamName: string): Promise<CaptureStream>;
+    getTelemetry(streamNameOrStreamNames: string | string[], start: Date, end: Date, tags?: {
+        [key in string]: string[];
+    }, limit?: number, offset?: number, latestOnly?: boolean): Promise<TelemetryResult[]>;
+    queryEvents(query: IEventQuery): Promise<IEvent[]>;
+    getTelemetryStreams(): Promise<TelemetryStream[]>;
+    createInterventionRequest<T extends InterventionType>(message: string, interventionType: InterventionType, interventionRequest: IInterventionTypeMap[T]["request"], tags?: {
+        [key in string]: string[];
+    }): Promise<(id: string) => IInterventionTypeMap[T]["response"]>;
+    addInterventionResponse<T extends InterventionType>(interventionId: string, interventionType: InterventionType, data: IInterventionTypeMap[T]["response"]): Promise<IInterventionResponse>;
+    getAnnotationCount(query: IEventQuery, tagKey: string): Promise<{
+        [key: string]: number;
+    }>;
+    getAnnotationCountByIntervals(query: IEventQuery, tagKey: string, aggregate: AggregateLevel): Promise<{
+        date: string;
+        annotations: {
+            [key: string]: number;
+        };
+    }[]>;
+    eventsCounter(eventTypes: EventType[], timeFrame: AggregateLevel, range: number, time: number, query?: IEventQuery): Promise<{
+        date: string;
+        events: IEvent[];
+    }[]>;
+    createShareLink(share: IShare, view: string): Promise<string | null>;
+}

package/dist/types/data-sdk/src/devices/ICustomDataChannelCreator.d.ts

@@ -0,0 +1,4 @@
+import { DataChannel } from "../DataChannel";
+export interface ICustomDataChannelCreator {
+    createCustomDataChannel(channelName: string, rtcConfig?: RTCDataChannelInit): Promise<DataChannel>;
+}

package/dist/types/data-sdk/src/devices/IRealtimeSubscriber.d.ts

@@ -0,0 +1,7 @@
+import { RealtimeDataStream, RealtimeListener } from "./device.types";
+export interface IRealtimeSubscriber {
+    addRealtimeListener(listener: RealtimeListener): void;
+    removeRealtimeListener(listener: RealtimeListener): void;
+    startListeningToRealtimeDataStream(stream: RealtimeDataStream): void;
+    stopListeningToRealtimeDataStream(stream: RealtimeDataStream): void;
+}

package/dist/types/data-sdk/src/devices/IView.d.ts

@@ -0,0 +1,29 @@
+export interface IView {
+    id: string;
+    tags: {
+        [key: string]: string;
+    };
+    organizationId: string;
+    name: string;
+    description?: string | null;
+    url?: string | null;
+    showOnSingleDevice?: boolean;
+    showOnMultiDevice?: boolean;
+    showOnTeleop?: boolean;
+    showOnAnalytics?: boolean;
+    showTimeline?: boolean;
+    localModeEnabled?: boolean;
+    filter: IFilter | null;
+    deviceFilter: IFilter | null;
+    groupFilter: IFilter | null;
+    layoutType?: string | null;
+    index: number;
+}
+export interface IFilter {
+    deviceIds?: string[];
+    names?: string[];
+    types?: any[];
+    tags?: any;
+    notTags?: any;
+    notNames?: string[];
+}

package/dist/types/data-sdk/src/devices/PeerDevice.d.ts

@@ -0,0 +1,35 @@
+import { IRtcPeer } from "@formant/realtime-sdk";
+import { IStreamCurrentValue } from "../model/IStreamCurrentValue";
+import { ConfigurationDocument } from "./device.types";
+import { BaseDevice } from "./BaseDevice";
+import { TelemetryResult } from "../model/TelemetryResult";
+import { IEventQuery } from "../model/IEventQuery";
+import { IEvent } from "../model/IEvent";
+import { IView } from "./IView";
+export declare class PeerDevice extends BaseDevice {
+    peerUrl: string;
+    id: string;
+    private telemetryStreamActive;
+    private streamTelemetry;
+    constructor(peerUrl: string);
+    getLatestTelemetry(): Promise<IStreamCurrentValue[]>;
+    getTelemetry(streamNameOrStreamNames: string | string[], start: Date, end: Date, tags?: {
+        [key in string]: string[];
+    }, limit?: number, offset?: number, latestOnly?: boolean): Promise<TelemetryResult[]>;
+    queryEvents(query: IEventQuery): Promise<IEvent[]>;
+    private checkKeysAndThrow;
+    private getPointPayload;
+    private subscribeToTelemetry;
+    private handleXHRError;
+    getDeviceId(): Promise<string>;
+    getConfiguration(): Promise<ConfigurationDocument>;
+    getViews(): Promise<IView[]>;
+    startRealtimeConnection(sessionType?: number): Promise<void>;
+    private initConnectionMonitoring;
+    getRemotePeer(): Promise<IRtcPeer>;
+    stopRealtimeConnection(): Promise<void>;
+    getCommandMetadata(): Promise<{
+        commands: any[];
+    }>;
+    sendCommand(name: string, data?: string, time?: Date, metadata?: {}): Promise<Response>;
+}

package/dist/types/data-sdk/src/devices/device.types.d.ts

@@ -0,0 +1,115 @@
+import { IRtcStreamPayload, RtcStreamType } from "@formant/realtime-sdk";
+import { IDictionary } from "../model/IDictionary";
+import { IFilter } from "../model/IFilter";
+import { IScopeFilter } from "../model/IScopeFilter";
+import { ITaggedEntity } from "../model/ITaggedEntity";
+import { ITags } from "../model/ITags";
+import { SessionType } from "../model/SessionType";
+import { Uuid } from "../model/Uuid";
+export interface ConfigurationDocument {
+    tags: ITags;
+    urdfFiles: string[];
+    telemetry?: {
+        streams?: {
+            name: string;
+            disabled?: boolean;
+            onDemand?: boolean;
+        }[];
+    };
+    teleop?: {
+        customStreams?: {
+            name: string;
+            rtcStreamType: RtcStreamType;
+        }[];
+        hardwareStreams?: {
+            name: string;
+            rtcStreamType: RtcStreamType;
+        }[];
+        rosStreams?: {
+            rtcStreamType: RtcStreamType;
+            topicName: string;
+            topicType: string;
+        }[];
+    };
+    adapters?: IAdapterConfiguration[];
+    application?: {
+        configurationMap: {
+            [key: string]: string;
+        };
+    };
+}
+export interface ICommandDeliverySettings {
+    ttlMs?: number;
+    retryable?: boolean;
+}
+export interface ICommandTemplate extends ITaggedEntity {
+    organizationId?: Uuid;
+    name: string;
+    command: string;
+    description?: string;
+    parameterEnabled: boolean;
+    allowParameterOverride?: boolean;
+    parameterValue?: string | null;
+    parameterMeta?: IDictionary;
+    deviceScope?: IScopeFilter;
+    enabled?: boolean;
+    deviceFilter: IFilter | null;
+    lambdaUri?: string | null;
+    deliverySettings?: ICommandDeliverySettings;
+    schema?: string | null;
+}
+export interface Command {
+    id: string;
+    name: string;
+    command: string;
+    description: string;
+    parameterEnabled: true;
+    parameterValue: string | null;
+    tags: ITags;
+    parameterMeta?: {
+        topic?: string;
+    };
+}
+export interface IJointState {
+    name: string[];
+    position: number[];
+    velocity?: number[];
+    effort?: number[];
+}
+export interface TelemetryStream {
+    name: string;
+    onDemand: boolean;
+}
+export interface IAdapterConfiguration {
+    id: Uuid;
+    name: string;
+    fileId: Uuid;
+    execCommand: string;
+    configuration?: string;
+}
+export type RealtimeMessage = {
+    header: {
+        created: number;
+        stream: {
+            entityId: string;
+            streamName: string;
+            streamType: RtcStreamType;
+        };
+    };
+    payload: IRtcStreamPayload;
+};
+export type RealtimeListener = (peerId: string, message: RealtimeMessage) => void;
+export type RealtimeAudioStream = {
+    name: string;
+};
+export type RealtimeVideoStream = {
+    name: string;
+};
+export type RealtimeDataStream = {
+    name: string;
+};
+export interface IStartRealtimeConnectionOptions {
+    sessionType?: SessionType;
+    deadlineMs?: number;
+    maxConnectRetries?: number;
+}

package/dist/types/data-sdk/src/init.d.ts

@@ -0,0 +1 @@
+export {};