@formant/data-sdk 1.64.0 → 1.66.0

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

@@ -0,0 +1,45 @@
+import { IRtcSendConfiguration, IRtcStreamMessage, RtcClient, IRtcPeer } from "@formant/realtime-sdk";
+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";
+    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 { CaptureStream } from "../CaptureStream";
+import { InterventionType } from "../model/InterventionType";
+import { IInterventionTypeMap } from "../model/IInterventionTypeMap";
+import { IInterventionResponse } from "../model/IInterventionResponse";
+import { IEventQuery } from "../model/IEventQuery";
+import { AggregateLevel } from "../model/AggregateLevel";
+import { EventType } from "../model/EventType";
+import { IShare } from "../model/IShare";
+import { SessionType } from "../model/SessionType";
+import { Command, ConfigurationDocument, IStartRealtimeConnectionOptions, TelemetryStream } from "./device.types";
+import { BaseDevice } from "./BaseDevice";
+import { ITags } from "../model/ITags";
+import { createDevice } from "../api/createDevice";
+import { patchDevice } from "../api/patchDevice";
+import { getDevicesData } from "../api/getDevicesData";
+import { queryDevicesData } from "../api/queryDevicesData";
+import { disableDevice } from "../api/disableDevice";
+import { TelemetryResult } from "../model/TelemetryResult";
+import { IEvent } from "../model/IEvent";
+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(): Promise<Command[]>;
+    sendCommand(name: string, data?: string, time?: Date, metadata?: {}): 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,91 @@
+import { IRtcStreamPayload, RtcStreamType } from "@formant/realtime-sdk";
+import { ITags } from "../model/ITags";
+import { Uuid } from "../model/Uuid";
+import { SessionType } from "../model/SessionType";
+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 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 {};

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

@@ -0,0 +1,174 @@
+export { Account } from "./Account";
+export { App } from "./App";
+export { AudioPlayer } from "./AudioPlayer";
+export { Authentication } from "./Authentication";
+export { CaptureStream } from "./CaptureStream";
+export { FORMANT_API_URL } from "./config";
+export { whichFormantApiUrl } from "./config/whichFormantApiUrl";
+export { DataChannel } from "./DataChannel";
+export { Device } from "./devices/Device";
+export { PeerDevice } from "./devices/PeerDevice";
+export { Fleet } from "./Fleet";
+export { KeyValue } from "./KeyValue";
+export { Manipulator } from "./Manipulator";
+export { BinaryRequestDataChannel, TextRequestDataChannel, } from "./RequestDataChannel";
+export { Role } from "./Role";
+export { User } from "./User";
+export type { CaptureSession } from "./CaptureStream";
+export type { DataChannelBinaryListener, DataChannelErrorListener, DataChannelListener, DataChannelStringListener, } from "./DataChannel";
+export type { Command, ConfigurationDocument, IAdapterConfiguration, IJointState, IStartRealtimeConnectionOptions, RealtimeAudioStream, RealtimeDataStream, RealtimeListener, RealtimeMessage, RealtimeVideoStream, TelemetryStream, } from "./devices/device.types";
+export type { RealtimeManipulatorConfig } from "./Manipulator";
+export type { DataPoint, ModuleData, QueryRange, Stream, StreamData, } from "./message-bus/listeners/addModuleDataListener";
+export type { EmbeddedAppMessage, IDevice, ModuleConfigurationMessage, } from "./message-bus/listeners/EmbeddedAppMessage";
+export type { AppMessage } from "./message-bus/senders/AppMessage";
+export type { IRtcSendConfiguration, IRtcStreamMessage, IRtcStreamPayload, RtcStreamType, } from "@formant/realtime-sdk";
+export * from "./model/AccessLevel";
+export * from "./model/accessLevels";
+export * from "./model/AggregateLevel";
+export * from "./model/aggregateLevels";
+export * from "./model/AnnotationAreaType";
+export * from "./model/AnnotationType";
+export * from "./model/annotationTypes";
+export * from "./model/EventSortableColumn";
+export * from "./model/EventType";
+export * from "./model/eventTypes";
+export * from "./model/HealthStatus";
+export * from "./model/healthStatuses";
+export * from "./model/HexRgbColor";
+export * from "./model/IAccount";
+export * from "./model/IAccountTree";
+export * from "./model/IAggregateRow";
+export * from "./model/IAnalyticsModule";
+export * from "./model/IAnalyticsModuleConfiguration";
+export * from "./model/IAnnotation";
+export * from "./model/IAnnotationAreaTypeMap";
+export * from "./model/IAnnotationQuery";
+export * from "./model/IBaseEntity";
+export * from "./model/IBaseEvent";
+export * from "./model/IBattery";
+export * from "./model/IBitset";
+export * from "./model/IBoundingBox";
+export * from "./model/IColorRGBA";
+export * from "./model/ICommandDeliveryEvent";
+export * from "./model/ICommandEventBase";
+export * from "./model/ICommandParameter";
+export * from "./model/ICommandRequest";
+export * from "./model/ICommandRequestEvent";
+export * from "./model/ICommandResponse";
+export * from "./model/ICommandResponseEvent";
+export * from "./model/IComment";
+export * from "./model/IConfigurationMap";
+export * from "./model/ICustomEvent";
+export * from "./model/IDataAggregate";
+export * from "./model/IDataPoint";
+export * from "./model/IDevice";
+export * from "./model/IDeviceQuery";
+export * from "./model/IEvent";
+export * from "./model/IEventFilter";
+export * from "./model/IEventQuery";
+export * from "./model/IEventSort";
+export * from "./model/IFieldParametersTypeMap";
+export * from "./model/IFile";
+export * from "./model/IFileInfo";
+export * from "./model/IFilter";
+export * from "./model/IFleet";
+export * from "./model/IGoal";
+export * from "./model/IGoalID";
+export * from "./model/IHealth";
+export * from "./model/IImage";
+export * from "./model/IImageAnnotation";
+export * from "./model/IInterventionRequest";
+export * from "./model/IInterventionResponse";
+export * from "./model/IInterventionTypeMap";
+export * from "./model/ILabel";
+export * from "./model/ILabeledPolygon";
+export * from "./model/ILabelingRequestData";
+export * from "./model/ILabelingResponseData";
+export * from "./model/ILocalization";
+export * from "./model/ILocation";
+export * from "./model/IMap";
+export * from "./model/IMarker3D";
+export * from "./model/IMarker3DArray";
+export * from "./model/InterventionType";
+export * from "./model/interventionTypes";
+export * from "./model/INumericAggregate";
+export * from "./model/INumericSetAggregateMap";
+export * from "./model/INumericSetEntry";
+export * from "./model/IOdometry";
+export * from "./model/IPath";
+export * from "./model/IPointCloud";
+export * from "./model/IPortForwardingSessionRecord";
+export * from "./model/IQuaternion";
+export * from "./model/IQuery";
+export * from "./model/IRole";
+export * from "./model/IRtcSessionRecord";
+export * from "./model/IScopeFilter";
+export * from "./model/ISelectionRequestData";
+export * from "./model/ISelectionResponseData";
+export * from "./model/IShare";
+export * from "./model/ISheetParameters";
+export * from "./model/IsoDate";
+export * from "./model/ISpreadsheetIdRange";
+export * from "./model/ISqlColumn";
+export * from "./model/ISqlQuery";
+export * from "./model/ISqlResult";
+export * from "./model/ISqlRow";
+export * from "./model/IStream";
+export * from "./model/IStreamAggregateData";
+export * from "./model/IStreamAggregateTypeMap";
+export * from "./model/IStreamColumn";
+export * from "./model/IStreamCurrentValue";
+export * from "./model/IStreamData";
+export * from "./model/IStreamTypeMap";
+export * from "./model/ISystemEvent";
+export * from "./model/ITaggedUsers";
+export * from "./model/ITagParameters";
+export * from "./model/ITags";
+export * from "./model/ITagSets";
+export * from "./model/ITaskReportColumn";
+export * from "./model/ITeleopRequestData";
+export * from "./model/ITeleopResponseData";
+export * from "./model/ITeleopSessionRecord";
+export * from "./model/ITransform";
+export * from "./model/ITransformNode";
+export * from "./model/ITriggeredEvent";
+export * from "./model/ITwist";
+export * from "./model/IUser";
+export * from "./model/IUserParameters";
+export * from "./model/IVector3";
+export * from "./model/IVideo";
+export * from "./model/IView";
+export * from "./model/JsonSchema";
+export { SessionTypeConstants as SessionType } from "./model/SessionType";
+export * from "./model/severities";
+export * from "./model/Severity";
+export * from "./model/SortOrder";
+export * from "./model/StreamType";
+export * from "./model/Timestamp";
+export * from "./model/Uuid";
+export * from "./model/VideoMimeType";
+export * from "./model/videoMimeTypes";
+export * from "./stores/IAuthenticationStore";
+export * from "./utils/aggregateFunctionUtils";
+export * from "./utils/timeout";
+export type { TelemetryResult } from "./model/TelemetryResult";
+export type { IAuthentication } from "./stores/IAuthentication";
+export type { IConfirmForgotPasswordRequest } from "./stores/IConfirmForgotPasswordRequest";
+export type { IRespondToNewPasswordRequiredChallengeRequest } from "./stores/IRespondToNewPasswordRequiredChallengeRequest";
+import "./init.ts";
+export { RtcClient, RtcClientV1, RtcSignalingClient, createRtcStreamMessage, } from "@formant/realtime-sdk";
+export * from "./connector/data/BaseUniverseDataConnector";
+export * from "./connector/data/LiveUniverseData";
+export * from "./connector/data/queryStore";
+export * from "./connector/data/TelemetryUniverseData";
+export * from "./connector/model/IPose";
+export * from "./connector/model/IUniverseData";
+export * from "./connector/model/IUniverseOdometry";
+export { defined, definedAndNotNull } from "../../common/defined";
+export type IUniverseGridMap = import("./connector/model/IUniverseGridMap").IUniverseGridMap;
+export type IUniverseOdometry = import("./connector/model/IUniverseOdometry").IUniverseOdometry;
+export type IPcd = import("./connector/model/IPcd").IPcd;
+export type IPose = import("./connector/model/IPose").IPose;
+export type IUniversePointCloud = import("./connector/model/IUniversePointCloud").IUniversePointCloud;
+export type IUniversePath = import("./connector/model/IUniversePath").IUniversePath;
+export type IUniverseData = import("./connector/model/IUniverseData").IUniverseData;

package/dist/types/data-sdk/src/message-bus/bidirectional/getDate.d.ts

@@ -0,0 +1 @@
+export declare function getDate(time?: Date, minTime?: Date, maxTime?: Date): Promise<unknown>;

package/dist/types/data-sdk/src/message-bus/bidirectional/prompt.d.ts

@@ -0,0 +1,5 @@
+import { JsonSchema } from "../../model/JsonSchema";
+export declare function prompt(schema: JsonSchema, options?: {
+    okText?: string;
+    cancelText?: string;
+}): Promise<any>;

package/dist/types/data-sdk/src/message-bus/listeners/EmbeddedAppMessage.d.ts

@@ -0,0 +1,54 @@
+import { ITags } from "../../model/ITags";
+export type DateResponseMessage = {
+    type: "date_response";
+    data: Date;
+};
+export interface IDevice {
+    name: string;
+    id: string;
+    tags: ITags;
+}
+export type OverviewDevicesMessage = {
+    type: "overview_devices";
+    data: IDevice[];
+};
+export type ModuleMenuItemClickedMessage = {
+    type: "module_menu_item_clicked";
+    menu: string;
+};
+export type ModuleConfigurationMessage = {
+    type: "module_configuration";
+    temporary: boolean;
+    configuration: string;
+};
+export type AuthTokenMessage = {
+    type: "auth_token";
+    token: string;
+};
+export type ModuleDataMessage = {
+    type: "module_data";
+    streams: {
+        [x: string]: any;
+    };
+    time: number;
+    queryRange: {
+        start: number;
+        end: number;
+    };
+};
+export type ChannelDataMessage = {
+    type: "channel_data";
+    channel: string;
+    source: string;
+    data: any;
+};
+export type PromptResponseMessage = {
+    type: "prompt_response";
+    promptId: string;
+    data: any;
+};
+export type FormantOnlineMessage = {
+    type: "formant_online";
+    online: boolean;
+};
+export type EmbeddedAppMessage = DateResponseMessage | OverviewDevicesMessage | ModuleMenuItemClickedMessage | AuthTokenMessage | ModuleDataMessage | ChannelDataMessage | PromptResponseMessage | FormantOnlineMessage | ModuleConfigurationMessage;

package/dist/types/data-sdk/src/message-bus/listeners/addAccessTokenRefreshListener.d.ts

@@ -0,0 +1 @@
+export declare function addAccessTokenRefreshListener(handler: (token: string) => void): () => void;

package/dist/types/data-sdk/src/message-bus/listeners/addChannelDataListener.d.ts

@@ -0,0 +1,4 @@
+export declare function addChannelDataListener(channel: string, handler: (e: {
+    source: string;
+    data: any;
+}) => void): () => void;

package/dist/types/data-sdk/src/message-bus/listeners/addMenuListener.d.ts

@@ -0,0 +1 @@
+export declare function addMenuListener(handler: (label: string) => void): () => void;

package/dist/types/data-sdk/src/message-bus/listeners/addModuleConfigurationListener.d.ts

@@ -0,0 +1,2 @@
+import { ModuleConfigurationMessage } from "./EmbeddedAppMessage";
+export declare function addModuleConfigurationListener(handler: (event: ModuleConfigurationMessage) => void): () => void;

package/dist/types/data-sdk/src/message-bus/listeners/addModuleDataListener.d.ts

@@ -0,0 +1,29 @@
+export interface ModuleData {
+    queryRange: QueryRange;
+    time: number;
+    streams: {
+        [stream_name: string]: Stream;
+    };
+}
+export interface QueryRange {
+    start: number;
+    end: number;
+}
+export interface Stream {
+    data: StreamData[];
+    loading: boolean;
+    tooMuchData: boolean;
+    type: string;
+}
+export interface StreamData {
+    points: DataPoint[];
+    deviceId: string;
+    agentId: string;
+    name: string;
+    tags: {
+        [key: string]: string;
+    };
+    type: string;
+}
+export type DataPoint = [number, any];
+export declare function addModuleDataListener(handler: (data: ModuleData) => void): () => void;

package/dist/types/data-sdk/src/message-bus/listeners/addOverviewDeviceListener.d.ts

@@ -0,0 +1,2 @@
+import { IDevice } from "./EmbeddedAppMessage";
+export declare function addOverviewDeviceListener(handler: (devices: IDevice[]) => void): () => void;

package/dist/types/data-sdk/src/message-bus/listeners/addStreamLIstener.d.ts

@@ -0,0 +1,3 @@
+import { StreamType } from "../../model/StreamType";
+import { IStreamData } from "../../model/IStreamData";
+export declare function addStreamListener(streamNames: string[], streamTypes: StreamType[], handler: (response: IStreamData[] | "too much data" | undefined) => void): () => void;