@formant/data-sdk 1.64.0 → 1.66.0

package/dist/types/data-sdk/src/api/patchStreams.d.ts

@@ -0,0 +1,2 @@
+import { IStream } from "../model/IStream";
+export declare function patchStream(stream: IStream): Promise<IStream>;

package/dist/types/data-sdk/src/api/patchView.d.ts

@@ -0,0 +1,2 @@
+import { IView } from "../model/IView";
+export declare function patchView(view: IView): Promise<IView>;

package/dist/types/data-sdk/src/api/queryAnalytics.d.ts

@@ -0,0 +1,43 @@
+import { ISqlQuery } from "../model/ISqlQuery";
+import { ISqlResult } from "../model/ISqlResult";
+/**
+ *Retrieves all stream rows
+ * @example
+ * // Body
+ * const analytics = await queryAnalytics({
+ *     aggregateLevel: "day",
+ *     orderByColumn: "TIMESTAMP",
+ *     streamColumns: [
+ *       {
+ *         streamName: "consumables_residual_percentage",
+ *         streamType: "numeric set",
+ *       },
+ *     ],
+ *   });
+ * //Returns
+ * {
+ *    aggregates: [],
+ *    columns: [
+ *              {
+ *                name: 'TIMESTAMP',
+ *                isNullable: true,
+ *                dataType: 'string',
+ *                tableName: 'NUMERIC_SET_MAIN'
+ *               }
+ * ],
+ *    items: [
+ *              {
+ *                axisLabel: "suction_blade",
+ *                name: "consumables_residual_percentage",
+ *                tableName: "NUMERIC_SET_TEST",
+ *                time: "2020-04-20T08:00:00.000Z",
+ *                type: "numeric set",
+ *                unitLabel: "percent"
+ *                }
+ * ],
+ *    rowCount: 14,
+ *    rows: []
+ *    sqlText: "SELECT dateadd(day, dayofweek(TIMESTAMP), to_timestamp_tz('4/20/2020')) AS TIMESTAMP, SUM(VALUE)"
+ * }
+ */
+export declare function queryAnalytics(query: ISqlQuery): Promise<ISqlResult>;

package/dist/types/data-sdk/src/api/queryDevices.d.ts

@@ -0,0 +1,3 @@
+import { IDeviceQuery } from "../model/IDeviceQuery";
+import { Device } from "../devices/Device";
+export declare function queryDevices(query: IDeviceQuery): Promise<Device[]>;

package/dist/types/data-sdk/src/api/queryDevicesData.d.ts

@@ -0,0 +1,3 @@
+import { IDeviceQuery } from "../model/IDeviceQuery";
+import { IDevice } from "../model/IDevice";
+export declare function queryDevicesData(query: IDeviceQuery): Promise<IDevice[]>;

package/dist/types/data-sdk/src/api/queryEvents.d.ts

@@ -0,0 +1,3 @@
+import { IEventQuery } from "../model/IEventQuery";
+import { IEvent } from "../model/IEvent";
+export declare function queryEvents(query: IEventQuery): Promise<IEvent[]>;

package/dist/types/data-sdk/src/api/queryTelemetry.d.ts

@@ -0,0 +1,3 @@
+import { IQuery } from "../model/IQuery";
+import { IStreamData } from "../model/IStreamData";
+export declare function queryTelemetry(query: IQuery): Promise<IStreamData<keyof import("../main").IStreamTypeMap>[]>;

package/dist/types/data-sdk/src/cache/StoreCache.d.ts

@@ -0,0 +1,19 @@
+export declare class StoreCache<Key, Value> {
+    private entries;
+    private metadata;
+    private capacity;
+    private staleIntervalMs;
+    constructor({ capacity, timeout, }?: {
+        capacity?: number;
+        timeout?: number;
+    });
+    get(key: Key, generator?: () => Promise<Value>): Value | undefined;
+    set(key: Key, value: Value): void;
+    clear(): void;
+    clearKey(key: string): void;
+    private keyToCacheKey;
+    private enforceMaxSize;
+    private isStale;
+    private isGenerating;
+    private generate;
+}

package/dist/types/data-sdk/src/cache/filterDataByTime.d.ts

@@ -0,0 +1,2 @@
+import { IStreamData } from "../model/IStreamData";
+export declare function filterDataByTime(datas: IStreamData[], start: Date, end: Date): IStreamData[];

package/dist/types/data-sdk/src/cache/filterDataByType.d.ts

@@ -0,0 +1,3 @@
+import { IStreamData } from "../model/IStreamData";
+import { StreamType } from "../model/StreamType";
+export declare function filterDataByType(datas: IStreamData[], type: StreamType[]): IStreamData[];

package/dist/types/data-sdk/src/cache/queryStore.d.ts

@@ -0,0 +1,11 @@
+import { IStreamData } from "../model/IStreamData";
+import { StreamType } from "../model/StreamType";
+import { IFilter } from "../model/IFilter";
+export declare class QueryStore {
+    private queryStoreCache;
+    private liveQueryStoreCache;
+    moduleQuery(filter: IFilter, name: string[], type: StreamType[], start: Date, end: Date, latestOnly?: boolean): IStreamData[] | "too much data" | undefined;
+    query(filter: IFilter, start: Date, end: Date, latestOnly?: boolean): IStreamData[] | "too much data" | undefined;
+    private queryCache;
+    private liveQueryCache;
+}

package/dist/types/data-sdk/src/config/index.d.ts

@@ -0,0 +1 @@
+export declare const FORMANT_API_URL: any;

package/dist/types/data-sdk/src/config/whichFormantApiUrl.d.ts

@@ -0,0 +1,6 @@
+interface IHasString {
+    get(key: string): string | null;
+    has(key: string): boolean;
+}
+export declare function whichFormantApiUrl(global: any, urlParams: IHasString, host?: string): any;
+export {};

package/dist/types/data-sdk/src/connector/common/Color.d.ts

@@ -0,0 +1,13 @@
+export declare class Color {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+    h: number;
+    s: number;
+    l: number;
+    static fromString(color: string): Color | undefined;
+    constructor(r: number, g: number, b: number, a?: number);
+    toString(): string;
+    withAlpha(a: number): Color;
+}

package/dist/types/data-sdk/src/connector/common/Timeout.d.ts

@@ -0,0 +1 @@
+export type Timeout = ReturnType<typeof setTimeout>;

package/dist/types/data-sdk/src/connector/common/defined.d.ts

@@ -0,0 +1,3 @@
+export declare function defined<T>(value: T | undefined, errorMessage?: string): T;
+export declare function notNull<T>(value: T | null, errorMessage?: string): T;
+export declare function definedAndNotNull<T>(value: T | undefined | null, errorMessage?: string): T;

package/dist/types/data-sdk/src/connector/common/delay.d.ts

@@ -0,0 +1 @@
+export declare function delay(ms: number): Promise<unknown>;

package/dist/types/data-sdk/src/connector/common/duration.d.ts

@@ -0,0 +1,10 @@
+export declare const duration: {
+    readonly millisecond: 1;
+    readonly second: 1000;
+    readonly minute: number;
+    readonly hour: number;
+    readonly day: number;
+    readonly week: number;
+    readonly month: number;
+    readonly year: number;
+};

package/dist/types/data-sdk/src/connector/common/equals.d.ts

@@ -0,0 +1 @@
+export declare function equals<T>(a: T, b: T): boolean;

package/dist/types/data-sdk/src/connector/common/filterDataByTime.d.ts

@@ -0,0 +1,2 @@
+import { IStreamData } from "../../model/IStreamData";
+export declare function filterDataByTime(datas: IStreamData[], start: Date, end: Date): IStreamData[];

package/dist/types/data-sdk/src/connector/common/filterDataByType.d.ts

@@ -0,0 +1,3 @@
+import { IStreamData } from "../../model/IStreamData";
+import { StreamType } from "../../model/StreamType";
+export declare function filterDataByType<T extends StreamType>(datas: IStreamData[], type: T): IStreamData<T>[];

package/dist/types/data-sdk/src/connector/common/flattenPoints.d.ts

@@ -0,0 +1,8 @@
+import { IStreamData, StreamType, Timestamp } from "../../main";
+export interface IFlattenedPoint {
+    streamName: string;
+    streamType: StreamType;
+    timestamp: Timestamp;
+    value: any;
+}
+export declare function flattenPoints(streamData: IStreamData): IFlattenedPoint[];

package/dist/types/data-sdk/src/connector/common/fork.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Used to fire-and-forget a promise.
+ * This is useful as a function wrapper to suppress floating promise warnings.
+ */
+export declare function fork<T>(_: Promise<T>): void;

package/dist/types/data-sdk/src/connector/common/range.d.ts

@@ -0,0 +1 @@
+export declare const range: (start: number, end: number) => number[];

package/dist/types/data-sdk/src/connector/common/throttle.d.ts

@@ -0,0 +1 @@
+export declare const throttle: <T>(callback: (...args: T[]) => void, time: number) => (...args: T[]) => void;

package/dist/types/data-sdk/src/connector/common/toJsonLines.d.ts

@@ -0,0 +1 @@
+export declare function toJsonLines(objects: any[]): string;

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

@@ -0,0 +1,68 @@
+import { H264BytestreamCanvasDrawer } from "@formant/ui-sdk-realtime-player-core";
+import { IRtcStreamMessage } from "@formant/realtime-sdk";
+import { ITransform } from "@formant/realtime-sdk/dist/model/ITransform";
+import { Device } from "../../devices/Device";
+import { PeerDevice } from "../../devices/PeerDevice";
+import { IBitset } from "../../model/IBitset";
+import { ILocation } from "../../model/ILocation";
+import { IStreamData } from "../../model/IStreamData";
+import { ITransformNode } from "../../model/ITransformNode";
+import { CloseSubscription, DataSourceState, IRealtimeStream, ITelemetryRosStream, ITelemetryStream, IUniverseStatistics, Interaction, RealtimeButtonConfiguration, UniverseDataSource } from "../model/IUniverseData";
+import { QueryStore } from "./queryStore";
+export type DeviceId = string;
+export type DataSourceId = string;
+export type DataResult<T> = {
+    deviceId: DeviceId;
+    sourceId: DataSourceId;
+    data: T | undefined;
+};
+export declare class BasicUniverseDataConnector {
+    subscriberSources: Map<string, Map<string, UniverseDataSource>>;
+    subscriberLoaders: Map<DeviceId, Map<DataSourceId, (data: any) => Promise<DataResult<any>>>>;
+    subscriberDistributorsLoaders: Map<DeviceId, Map<DataSourceId, ((data: any) => void)[]>>;
+    mapRealtimeConnections: Map<string, Device | PeerDevice | "loading">;
+    lastQueriedHistoricTime: Date | undefined;
+    time: Date | "live";
+    timeChangeListeners: ((time: Date | "live") => void)[];
+    queryStore: QueryStore;
+    setTime(time: Date | "live"): void;
+    getTime(): Date | "live";
+    getTimeMs(): number;
+    constructor();
+    private generateTelemetryFilter;
+    protected sendRtcMessage(deviceId: string, msg: IRtcStreamMessage): Promise<void>;
+    protected createRealtimeConnection(deviceId: string, sessionType?: number): Promise<void>;
+    protected addRemovableTelemetrySubscription<T>(deviceId: string, source: UniverseDataSource, loader: (data: IStreamData[]) => Promise<DataResult<T>>, distribute: (data: T) => void): () => void;
+    protected createH264Drawer(): H264BytestreamCanvasDrawer;
+    sendCommand(deviceId: string, name: string, data?: string | undefined): Promise<void>;
+    sendRealtimePose(deviceId: string, streamName: string, pose: ITransform): Promise<void>;
+    sendRealtimeBoolean(deviceId: string, streamName: string, value: boolean): Promise<void>;
+    sendRealtimeBitset(deviceId: string, streamName: string, bitset: IBitset): Promise<void>;
+    getUrdfs(deviceId: string): Promise<string[]>;
+    getTelemetryStreams(_deviceId: string): Promise<ITelemetryStream[]>;
+    getTeleopRosStreams(_deviceId: string): Promise<ITelemetryRosStream[]>;
+    getHardwareStreams(_deviceId: string): Promise<IRealtimeStream[]>;
+    addInteraction(_interaction: Interaction): void;
+    removeInteraction(_id: string): void;
+    getInteractions(): Interaction[];
+    addInteractionsChangedListener(_callback: (interactions: Interaction[]) => void): () => void;
+    addInteractionListener(_callback: (interaction: Interaction) => void): () => void;
+    getRealtimeButtons(_deviceId: string): Promise<RealtimeButtonConfiguration[]>;
+    getLatestTransformTrees(_deviceId: string): Promise<{
+        streamName: string;
+        transformTree: ITransformNode;
+    }[]>;
+    getLatestLocations(): 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>;
+    getStatistics(): Promise<IUniverseStatistics>;
+    subscribeDataSourceStateChange(_deviceId: string, _source: UniverseDataSource, _onDataSourceStateChange?: (state: DataSourceState) => void): CloseSubscription;
+    fetchImage(url: string): Promise<HTMLImageElement>;
+}

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

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

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

@@ -0,0 +1,36 @@
+import { RealtimeListener } from "../../devices/device.types";
+import { IBitset } from "../../model/IBitset";
+import { IJointState } from "../../model/IJointState";
+import { INumericSetEntry } from "../../model/INumericSetEntry";
+import { ITransformNode } from "../../model/ITransformNode";
+import { IPose } from "../model/IPose";
+import { CloseSubscription, IUniverseData, UniverseDataSource } from "../model/IUniverseData";
+import { IUniverseGridMap } from "../model/IUniverseGridMap";
+import { IUniverseOdometry } from "../model/IUniverseOdometry";
+import { IUniversePath } from "../model/IUniversePath";
+import { IUniversePointCloud } from "../model/IUniversePointCloud";
+import { ILocation } from "../../model/ILocation";
+import { IMarker3DArray } from "../../model/IMarker3DArray";
+import { BasicUniverseDataConnector } from "./BaseUniverseDataConnector";
+export declare class LiveUniverseData extends BasicUniverseDataConnector implements IUniverseData {
+    constructor();
+    subscribeToPath(_deviceId: string, _source: UniverseDataSource, _callback: (data: Symbol | IUniversePath) => void): CloseSubscription;
+    subscribeToImage(_deviceId: string, _source: UniverseDataSource, _callback: (image: HTMLCanvasElement) => void): CloseSubscription;
+    subcribeToVideo(_deviceId: string, _source: UniverseDataSource, _callback: (frame: HTMLVideoElement) => void): CloseSubscription;
+    subscribeToBitset(deviceId: string, source: UniverseDataSource, callback: (data: IBitset | Symbol) => void): CloseSubscription;
+    subscribeToOdometry(deviceId: string, source: UniverseDataSource, callback: (data: IUniverseOdometry) => void, _trail?: number): CloseSubscription;
+    subscribeToPose(deviceId: string, source: UniverseDataSource, callback: (data: IPose) => void): CloseSubscription;
+    subscribeToNumeric(deviceId: string, source: UniverseDataSource, callback: (num: [number, number][]) => void): CloseSubscription;
+    subscribeToNumericSet(deviceId: string, source: UniverseDataSource, callback: (entry: [number, INumericSetEntry[]][]) => void): CloseSubscription;
+    subscribeToRealtimeMessages(deviceId: string, streamName: string, callback: RealtimeListener): Promise<void>;
+    unsubscribeToRealtimeMessages(deviceId: string, streamName: string, callback: RealtimeListener): Promise<void>;
+    subscribeToJson<T>(deviceId: string, source: UniverseDataSource, callback: (data: T) => void): CloseSubscription;
+    subscribeToText(deviceId: string, source: UniverseDataSource, callback: (data: string) => void): CloseSubscription;
+    subscribeToPointCloud(deviceId: string, source: UniverseDataSource, callback: (data: IUniversePointCloud) => void): () => void;
+    subscribeToGeometry(_deviceId: string, _source: UniverseDataSource, _callback: (data: IMarker3DArray) => void): () => void;
+    subscribeToJointState(deviceId: string, source: UniverseDataSource, callback: (data: IJointState) => void): () => void;
+    subscribeToGridMap(deviceId: string, source: UniverseDataSource, callback: (data: IUniverseGridMap) => void): () => void;
+    subscribeToVideo(deviceId: string, source: UniverseDataSource, callback: (frame: HTMLCanvasElement) => void): () => void;
+    subscribeToTransformTree(deviceId: string, source: UniverseDataSource, callback: (data: ITransformNode) => void): () => void;
+    subscribeToLocation(_deviceId: string, _source: UniverseDataSource, _callback: (data: ILocation) => void): () => void;
+}

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

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

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

@@ -0,0 +1,17 @@
+export declare class StoreCache<Key, Value> {
+    private entries;
+    private metadata;
+    private capacity;
+    private timeout;
+    constructor({ capacity, timeout, }?: {
+        capacity?: number;
+        timeout?: number;
+    });
+    get(key: Key, generator?: () => Promise<Value>): Value | undefined;
+    set(key: Key, value: Value): void;
+    clear(): void;
+    clearKey(key: string): void;
+    private keyToCacheKey;
+    private deleteOldestEntry;
+    private generate;
+}

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

@@ -0,0 +1,44 @@
+import { IBitset } from "../../model/IBitset";
+import { IDataPoint } from "../../model/IDataPoint";
+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 "../model/IPose";
+import { CloseSubscription, IUniverseData, UniverseDataSource } from "../model/IUniverseData";
+import { IUniverseGridMap } from "../model/IUniverseGridMap";
+import { IUniverseOdometry } from "../model/IUniverseOdometry";
+import { IUniversePath } from "../model/IUniversePath";
+import { IUniversePointCloud } from "../model/IUniversePointCloud";
+import { BasicUniverseDataConnector } from "./BaseUniverseDataConnector";
+import { StoreCache } from "./StoreCache";
+export declare class TelemetryUniverseData extends BasicUniverseDataConnector implements IUniverseData {
+    liveIntervalHandle: number | undefined;
+    constructor();
+    subscribeToBitset(_deviceId: string, _source: UniverseDataSource, _callback: (data: IBitset | Symbol) => void): CloseSubscription;
+    subscribeToPath(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | IUniversePath) => void): CloseSubscription;
+    onTimeChange(time: Date | "live"): void;
+    findDataForTime(time: Date): void;
+    timeFinders: ((time: Date) => void)[];
+    addFinder<T extends StreamType>(callback: (f: "too much data" | IDataPoint<T>[] | undefined) => Promise<void>, deviceId: string, name: string, dataType: T, latestOnly: boolean): (time: Date) => void;
+    private getNearestPoint;
+    removeFinder(fn: (time: Date) => void): void;
+    subscribeTelemetry<T extends StreamType>(deviceId: string, source: UniverseDataSource, type: T, callback: (f: "too much data" | IDataPoint<T>[] | undefined) => Promise<void>): CloseSubscription;
+    subscribeToPointCloud(deviceId: string, source: UniverseDataSource, callback: (data: IUniversePointCloud | Symbol) => void): CloseSubscription;
+    subscribeToOdometry(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | IUniverseOdometry) => void, trail?: number): CloseSubscription;
+    subscribeToPose(_deviceId: string, _source: UniverseDataSource, _callback: (data: Symbol | IPose) => void): CloseSubscription;
+    subscribeToGeometry(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | IMarker3DArray) => void): CloseSubscription;
+    subscribeToJointState(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | IJointState) => void): CloseSubscription;
+    subscribeToGridMap(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | IUniverseGridMap) => void): CloseSubscription;
+    videoCache: StoreCache<string, HTMLVideoElement>;
+    subscribeToVideo(deviceId: string, source: UniverseDataSource, callback: (frame: Symbol | HTMLCanvasElement) => void): CloseSubscription;
+    subscribeToTransformTree(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | ITransformNode) => void): CloseSubscription;
+    subscribeToLocation(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | ILocation) => void): CloseSubscription;
+    subscribeToJson<T>(deviceId: string, source: UniverseDataSource, callback: (data: Symbol | T) => void): CloseSubscription;
+    subscribeToText(deviceId: string, source: UniverseDataSource, callback: (text: string | Symbol) => void): CloseSubscription;
+    subscribeToNumeric(deviceId: string, source: UniverseDataSource, callback: (num: Symbol | [number, number][]) => void): CloseSubscription;
+    subscribeToNumericSet(deviceId: string, source: UniverseDataSource, callback: (entry: Symbol | [number, INumericSetEntry[]][]) => void): CloseSubscription;
+    subscribeToImage(deviceId: string, source: UniverseDataSource, callback: (image: Symbol | HTMLCanvasElement) => void): CloseSubscription;
+}

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

@@ -0,0 +1,23 @@
+export type Field = "x" | "y" | "z" | "rgb" | "rgba" | "intensity";
+export type Type = "i" | "u" | "f";
+export type Data = "ascii" | "binary" | "binary_compressed";
+export interface IPcdHeader {
+    version: string;
+    fields: Field[];
+    size: number[];
+    type: Type[];
+    count: number[];
+    height: number;
+    width: number;
+    points: number;
+    data: Data;
+}
+export interface IPcd {
+    header: IPcdHeader;
+    positions?: Float32Array;
+    colors?: Float32Array;
+    intensity?: Float32Array;
+}
+export declare function parse(buffer: ArrayBuffer): IPcd;
+export declare function loadFromUrl(path: string): Promise<IPcd>;
+export declare function loadFromBase64(data: string): IPcd;

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

@@ -0,0 +1,12 @@
+import { IFilter } from "../../model/IFilter";
+import { IQuery } from "../../model/IQuery";
+import { IStreamData } from "../../model/IStreamData";
+import { StreamType } from "../../model/StreamType";
+export declare class QueryStore {
+    private queryStoreCache;
+    private liveQueryStoreCache;
+    moduleQuery<T extends StreamType>(filter: IFilter, name: string, type: T, start: Date, end: Date, latestOnly?: boolean): IStreamData<T>[] | "too much data" | undefined;
+    query(q: IQuery): IStreamData[] | "too much data" | undefined;
+    private queryCache;
+    private liveQueryCache;
+}

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

@@ -0,0 +1 @@
+export declare const range: (start: number, end: number) => number[];

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

@@ -0,0 +1,20 @@
+export type Field = "x" | "y" | "z" | "rgb" | "rgba" | "intensity";
+export type Type = "i" | "u" | "f";
+export type Data = "ascii" | "binary" | "binary_compressed";
+export interface IPcdHeader {
+    version: string;
+    fields: Field[];
+    size: number[];
+    type: Type[];
+    count: number[];
+    height: number;
+    width: number;
+    points: number;
+    data: Data;
+}
+export interface IPcd {
+    header: IPcdHeader;
+    positions?: Float32Array | number[];
+    colors?: Float32Array | number[];
+    intensity?: Float32Array | number[];
+}

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

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

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;
+}