@formant/data-sdk 1.80.4 → 1.80.5

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

@@ -0,0 +1,2 @@
+import { IEventTriggerGroup } from "../model/IEventTriggerGroup";
+export declare function patchEventTriggerGroup(id: string, eventTrigger: Partial<IEventTriggerGroup>): Promise<IEventTriggerGroup>;

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

@@ -0,0 +1,2 @@
+import { IFleet } from "../model/IFleet";
+export declare function patchFleet(id: string, role: Partial<IFleet>): Promise<IFleet>;

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/api/teleopViews.d.ts

@@ -0,0 +1,73 @@
+import { RtcStreamType } from "../connector/model/IUniverseData";
+import { IsoDate } from "../model/IsoDate";
+import { ITags } from "../model/ITags";
+export interface IDictionary<T = string> {
+    [key: string]: T;
+}
+export interface ITeleopViewModule {
+    id: string;
+    type: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    size: {
+        width: number;
+        height: number;
+    };
+    isButton?: boolean;
+    label?: string;
+    isTextInput?: boolean;
+    config: ModuleConfig;
+}
+export interface ITeleopViewConfiguration {
+    modules: ITeleopViewModule[];
+    modulePickerPosition: {
+        x: number;
+        y: number;
+    };
+}
+export interface ITeleopView {
+    id: string;
+    organizationId: string;
+    name: string;
+    configuration: ITeleopViewConfiguration;
+    createdAt?: IsoDate;
+    updatedAt?: IsoDate;
+    tags?: ITags;
+}
+export interface ITeleopViewResponse {
+    items: ITeleopView[];
+}
+export type ModuleConfigItem = {
+    id: string;
+    name: string;
+    type: "realtime-streams";
+    multiple?: boolean;
+    supportedTypes: RtcStreamType[];
+} | {
+    id: string;
+    name: string;
+    type: "named-string";
+    defaultValue: string;
+} | {
+    id: string;
+    name: string;
+    type: "named-boolean";
+    defaultValue: boolean;
+} | {
+    id: string;
+    name: string;
+    type: "named-number";
+    defaultValue: number;
+};
+export type ConfigValue = string | number | boolean | any[];
+export type ModuleConfig = {
+    [key: string]: ConfigValue;
+};
+export declare function request<T>(endpoint: string, options?: RequestInit): Promise<T>;
+export declare function fetchTeleopViews(): Promise<ITeleopView[]>;
+export declare function getTeleopView(id: string): Promise<ITeleopView>;
+export declare function createTeleopView(view: Omit<ITeleopView, "id" | "organizationId" | "createdAt" | "updatedAt">): Promise<ITeleopView>;
+export declare function updateTeleopView(id: string, view: Partial<ITeleopView>): Promise<ITeleopView>;
+export declare function deleteTeleopView(id: string): Promise<void>;

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,2 @@
+export declare let FORMANT_API_URL: any;
+export declare const setFormantApiUrl: (url: string) => void;

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/LruCache.d.ts

@@ -0,0 +1,18 @@
+import BaseLruCache from "lru-cache";
+export type CacheOptions<V> = BaseLruCache.Options<string, V> & {
+    name: string;
+    fastStringify?: boolean;
+};
+export declare class LruCache<K, V> {
+    private cache;
+    private stringify;
+    constructor(options: CacheOptions<V>);
+    set(key: K, value: V, ttl?: number): void;
+    get(key: K): V | undefined;
+    delete(key: K): void;
+    peek(key: K): V | undefined;
+    size(): number;
+    clear(): void;
+    forEach(callback: (value: V) => void): void;
+    purgeStale(): boolean;
+}

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

@@ -0,0 +1,11 @@
+import { CacheOptions, LruCache } from "./LruCache";
+export type PromiseCacheOptions<V> = CacheOptions<Promise<V>> & {
+    expireRejectedPromiseValues?: boolean;
+    rejectedPromiseValueTtl?: number;
+};
+export declare class PromiseLruCache<K, V> extends LruCache<K, Promise<V>> {
+    protected expireRejectedPromiseValues: boolean;
+    protected rejectedPromiseValueTtl: number;
+    constructor(options: PromiseCacheOptions<V>);
+    set(key: K, value: Promise<V>, ttl?: number): void;
+}

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/errorToObject.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Convert an error object to plain javascript object, including any custom properties.
+ */
+export declare function errorToObject(error: any): {
+    message: string;
+    name?: undefined;
+    stack?: undefined;
+    meta?: undefined;
+} | {
+    name: any;
+    message: any;
+    stack: any;
+    meta: any;
+};

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

@@ -0,0 +1,4 @@
+/**
+ * Serialize an error object to a string, including any custom properties.
+ */
+export declare function errorToString(error: unknown): string;

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/common/toStringSafe.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Safely stringify input.
+ * Similar to `JSON.stringify` but
+ * doesn't throw an error if input includes circular properties.
+ *
+ * Warning: output is not guaranteed to be a valid JSON string.
+ */
+export declare function toStringSafe(input: unknown): string;

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

@@ -0,0 +1,69 @@
+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;
+    dataLoader: any;
+    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/loader/DataLoader.d.ts

@@ -0,0 +1,27 @@
+type JsonPrimitive = string | number | boolean | null;
+interface IJsonMap {
+    [member: string]: JsonPrimitive | IJsonArray | IJsonMap;
+}
+interface IJsonArray extends Array<JsonPrimitive | IJsonArray | IJsonMap> {
+}
+export type Json = IJsonMap | IJsonArray | JsonPrimitive;
+export interface IDataLoaderResult {
+    json: Json;
+    preview: string;
+    length: number;
+}
+export declare class DataLoader {
+    private static references;
+    private static instance;
+    static get(): DataLoader;
+    static release(loader: DataLoader): void;
+    private workers;
+    private cache;
+    private nextWorkerIndex;
+    private resolveMap;
+    private rejectMap;
+    private constructor();
+    load(url: string): Promise<IDataLoaderResult>;
+    private nextWorker;
+}
+export {};

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

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

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