@formant/data-sdk 0.0.90 → 0.0.93

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

@@ -0,0 +1,28 @@
+export interface User {
+    firstName: string;
+    lastName: string;
+    email: string;
+    organizationId: string;
+    id: string;
+}
+export interface IAuthentication {
+    accessToken: string;
+    organizationId: string;
+    refreshToken: string;
+    userId: string;
+}
+export declare class Authentication {
+    static token: string | undefined;
+    static refreshToken: string | undefined;
+    static currentUser: User | undefined;
+    static currentOrganization: string | undefined;
+    static isShareToken: boolean;
+    static defaultDeviceId: string | undefined;
+    static waitingForAuth: ((result: boolean) => void)[];
+    static login(email: string, password: string): Promise<IAuthentication | Error>;
+    static loginWithToken(token: string, refreshToken?: string): Promise<void>;
+    static isAuthenticated(): boolean;
+    static getCurrentUser(): User | undefined;
+    static waitTilAuthenticated(): Promise<boolean>;
+    static listenForRefresh(): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+export interface CaptureSession {
+    deviceId: string;
+    streamName: string;
+    tags: {};
+    expiration: string;
+    organizationId: string;
+    userId: string;
+    code: string;
+    id: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare class CaptureStream {
+    captureSession: CaptureSession;
+    token: string | undefined;
+    constructor(captureSession: CaptureSession);
+    ingestJSON(value: {}): Promise<void>;
+}

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

@@ -0,0 +1,18 @@
+export declare type DataChannelStringListener = (message: string) => void;
+export declare type DataChannelBinaryListener = (message: Uint8Array) => void;
+export declare class DataChannel {
+    private dataChannel;
+    ready: boolean;
+    listeners: DataChannelStringListener[];
+    binaryListeners: DataChannelBinaryListener[];
+    error: string | undefined;
+    decoder: TextDecoder;
+    constructor(dataChannel: RTCDataChannel);
+    waitTilReady(): Promise<boolean>;
+    send(data: string): void;
+    sendBinary(data: Uint8Array): void;
+    addListener(listener: DataChannelStringListener): void;
+    removeListener(listener: DataChannelStringListener): void;
+    addBinaryListener(listener: DataChannelBinaryListener): void;
+    removeBinaryListener(listener: DataChannelBinaryListener): void;
+}

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

@@ -0,0 +1,112 @@
+import { IRtcConnectConfiguration, RtcClient } from "@formant/realtime-sdk";
+import { DataChannel } from "./DataChannel";
+import { CaptureStream } from "./CaptureStream";
+import { Manipulator } from "./Manipulator";
+import { TextRequestDataChannel, BinaryRequestDataChannel } from "./RequestDataChannel";
+import { InterventionType } from "./main";
+import { IInterventionTypeMap } from "./main";
+import { IInterventionResponse } from "./main";
+export interface ConfigurationDocument {
+    urdfFiles: string[];
+    telemetry?: {
+        streams?: {
+            name: string;
+            disabled?: boolean;
+            onDemand?: boolean;
+        }[];
+    };
+}
+export interface Command {
+    id: string;
+    name: string;
+    command: string;
+    description: string;
+    parameterEnabled: true;
+    parameterValue: string | null;
+    parameterMeta?: {
+        topic?: string;
+    };
+}
+export interface IJointState {
+    name: string[];
+    position: number[];
+    velocity?: number[];
+    effort?: number[];
+}
+export interface TelemetryStream {
+    name: string;
+    onDemand: boolean;
+}
+export declare type RealtimeMessage = {
+    header: {
+        created: number;
+        stream: {
+            entityId: string;
+            streamName: string;
+            streamType: string;
+        };
+    };
+    payload: any;
+};
+export declare type RealtimeListener = (peerId: string, message: RealtimeMessage) => void;
+export declare type RealtimeVideoStream = {
+    name: string;
+};
+export declare type RealtimeDataStream = {
+    name: string;
+};
+export declare const SessionType: {
+    Teleop: number;
+    Observe: number;
+};
+export interface IRealtimeDevice {
+    startRealtimeConnection(config?: IRtcConnectConfiguration): Promise<void>;
+    startListeningToRealtimeDataStream(stream: RealtimeDataStream): Promise<void>;
+    stopListeningToRealtimeDataStream(stream: RealtimeDataStream): Promise<void>;
+    addRealtimeListener(listener: RealtimeListener): void;
+    removeRealtimeListener(listener: RealtimeListener): void;
+    createCustomDataChannel(channelName: string, rtcConfig?: RTCDataChannelInit): Promise<DataChannel>;
+}
+export declare class Device implements IRealtimeDevice {
+    id: string;
+    name: string;
+    private organizationId;
+    rtcClient: RtcClient | undefined;
+    remoteDevicePeerId: string | undefined;
+    realtimeListeners: RealtimeListener[];
+    constructor(id: string, name: string, organizationId: string);
+    getLatestTelemetry(): Promise<any>;
+    getConfiguration(): Promise<ConfigurationDocument>;
+    getFileUrl(fileId: string): Promise<string[]>;
+    private handleMessage;
+    getRealtimeStatus(): "disconnected" | "connecting" | "connected";
+    getRealtimePing(): number | undefined;
+    startRealtimeConnection(config?: IRtcConnectConfiguration): Promise<void>;
+    addRealtimeListener(listener: RealtimeListener): void;
+    removeRealtimeListener(listener: RealtimeListener): void;
+    getRealtimeVideoStreams(): Promise<RealtimeVideoStream[]>;
+    getRealtimeManipulators(): Promise<Manipulator[]>;
+    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>;
+    getRemotePeer(): Promise<import("@formant/realtime-sdk/dist/model/IRtcPeer").IRtcPeer>;
+    stopRealtimeConnection(): Promise<void>;
+    isInRealtimeSession(): Promise<boolean>;
+    getAvailableCommands(): Promise<Command[]>;
+    sendCommand(name: string, data?: string, time?: Date, metadata?: {}): Promise<any>;
+    createCustomDataChannel(channelName: string, rtcConfig?: RTCDataChannelInit): Promise<DataChannel>;
+    createCustomRequestDataChannel(channelName: string, timeout?: number): TextRequestDataChannel;
+    createCustomBinaryRequestDataChannel(channelName: string, timeout?: number): BinaryRequestDataChannel;
+    createCaptureStream(streamName: string): Promise<CaptureStream>;
+    getTelemetry(streamNameOrStreamNames: string | string[], start: Date, end: Date, tags?: {
+        [key in string]: string[];
+    }): Promise<import("./Fleet").TelemetryResult[]>;
+    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>;
+}

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

@@ -0,0 +1,40 @@
+import { Device } from "./Device";
+import { IRtcPeer } from "@formant/realtime-sdk/dist/model/IRtcPeer";
+import { IEventQuery } from "./model/IEventQuery";
+import { IEvent } from "./model/IEvent";
+import { IQuery } from "./model/IQuery";
+import { IStreamData } from "./model/IStreamData";
+import { PeerDevice } from "./PeerDevice";
+export interface TelemetryResult {
+    deviceId: string;
+    name: string;
+    points: [number, any][];
+    tags: {
+        [key in string]: string | number;
+    };
+    type: string;
+}
+export declare class Fleet {
+    static defaultDeviceId: string | undefined;
+    static knownContext: WeakRef<Device>[];
+    static setDefaultDevice(deviceId: string): Promise<void>;
+    static getCurrentDevice(): Promise<Device>;
+    static getPeerDevice(url: string): Promise<PeerDevice>;
+    static getDevice(deviceId: string): Promise<Device>;
+    static getDevices(): Promise<Device[]>;
+    static getOnlineDevices(): Promise<Device[]>;
+    static getPeers(): Promise<IRtcPeer[]>;
+    static getRealtimeSessions(): Promise<{
+        [key in string]: string[];
+    }>;
+    static getRealtimeDevices(): Promise<Device[]>;
+    static getLatestTelemetry(deviceIdOrDeviceIds?: string | string[]): Promise<any>;
+    static getTelemetry(deviceIdOrDeviceIds: string | string[], streamNameOrStreamNames: string | string[], start: Date, end: Date, tags?: {
+        [key in string]: string[];
+    }): Promise<TelemetryResult[]>;
+    static getFileUrl(uuid: string): Promise<string>;
+    static queryTelemetry(query: IQuery): Promise<IStreamData<keyof import("./main").IStreamTypeMap>[]>;
+    static queryEvents(query: IEventQuery): Promise<IEvent[]>;
+    static getEvent(uuid: string): Promise<IEvent>;
+    static getInterventions(): Promise<IEvent[]>;
+}

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

@@ -0,0 +1,4 @@
+export declare class KeyValue {
+    static set(key: string, value: string): Promise<void>;
+    static get(key: string): Promise<string>;
+}

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

@@ -0,0 +1,20 @@
+import { RealtimeDataStream, IJointState, RealtimeMessage, IRealtimeDevice } from "./Device";
+export declare type RealtimeManipulatorConfig = {
+    currentJointStateStream: RealtimeDataStream;
+    plannedJointStateStream?: RealtimeDataStream;
+    planValidStream?: RealtimeDataStream;
+    endEffectorStream?: RealtimeDataStream;
+    endEffectorLinkName?: string;
+    baseReferenceFrame?: string;
+    localFrame?: string;
+};
+export declare class Manipulator {
+    private device;
+    private config;
+    currentListeners: ((js: IJointState) => void)[];
+    constructor(device: IRealtimeDevice, config: RealtimeManipulatorConfig);
+    synchronize(): Promise<void>;
+    desynchronize(): Promise<void>;
+    onRealtimeMessage: (_peerId: string, message: RealtimeMessage) => void;
+    addCurrentJointStateListener(listener: (js: IJointState) => void): Promise<void>;
+}

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

@@ -0,0 +1,37 @@
+import { IRtcConnectConfiguration, RtcClient } from "@formant/realtime-sdk";
+import { DataChannel } from "./DataChannel";
+import { Manipulator } from "./Manipulator";
+import { TextRequestDataChannel, BinaryRequestDataChannel } from "./RequestDataChannel";
+import { ConfigurationDocument, IRealtimeDevice, RealtimeDataStream, RealtimeListener, RealtimeVideoStream } from "./Device";
+import { IStreamCurrentValue } from "./model/IStreamCurrentValue";
+import { IRtcPeer } from "@formant/realtime-sdk/dist/model/IRtcPeer";
+export declare class PeerDevice implements IRealtimeDevice {
+    peerUrl: string;
+    rtcClient: RtcClient | undefined;
+    remoteDevicePeerId: string | undefined;
+    realtimeListeners: RealtimeListener[];
+    id: string;
+    constructor(peerUrl: string);
+    getLatestTelemetry(): Promise<IStreamCurrentValue[]>;
+    getDeviceId(): Promise<string>;
+    getConfiguration(): Promise<ConfigurationDocument>;
+    private handleMessage;
+    getRealtimeStatus(): "disconnected" | "connecting" | "connected";
+    getRealtimePing(): number | undefined;
+    startRealtimeConnection(_config?: IRtcConnectConfiguration): Promise<void>;
+    addRealtimeListener(listener: RealtimeListener): void;
+    removeRealtimeListener(listener: RealtimeListener): void;
+    getRealtimeVideoStreams(): Promise<RealtimeVideoStream[]>;
+    getRealtimeManipulators(): Promise<Manipulator[]>;
+    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>;
+    getRemotePeer(): Promise<IRtcPeer>;
+    stopRealtimeConnection(): Promise<void>;
+    createCustomDataChannel(channelName: string, rtcConfig?: RTCDataChannelInit): Promise<DataChannel>;
+    createCustomRequestDataChannel(channelName: string, timeout?: number): TextRequestDataChannel;
+    createCustomBinaryRequestDataChannel(channelName: string, timeout?: number): BinaryRequestDataChannel;
+}

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

@@ -0,0 +1,23 @@
+import { DataChannel } from "./main";
+import { IRealtimeDevice } from "./Device";
+declare abstract class RequestDataChannel {
+    protected device: IRealtimeDevice;
+    protected channel_name: string;
+    protected timeout: number;
+    protected channel: undefined | DataChannel;
+    protected requestIdToResponseMap: Map<string, any>;
+    constructor(device: IRealtimeDevice, channel_name: string, timeout: number);
+}
+export declare class BinaryRequestDataChannel extends RequestDataChannel {
+    private RESPONSE_SUCCESS_BYTE;
+    private decoder;
+    generateBinaryId(): Uint8Array;
+    initialize(): Promise<void>;
+    request(data: Uint8Array): Promise<any>;
+}
+export declare class TextRequestDataChannel extends RequestDataChannel {
+    generateTextId(): string;
+    initialize(): Promise<void>;
+    request(data: string): Promise<any>;
+}
+export {};

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

@@ -0,0 +1 @@
+export declare let FORMANT_API_URL: string;

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

@@ -0,0 +1,105 @@
+export * from "./Fleet";
+export * from "./Authentication";
+export * from "./Device";
+export * from "./PeerDevice";
+export * from "./DataChannel";
+export * from "./CaptureStream";
+export * from "./Manipulator";
+export * from "./RequestDataChannel";
+export * from "./App";
+export * from "./KeyValue";
+export * from "./model/accessLevels";
+export * from "./model/AccessLevel";
+export * from "./model/aggregateLevels";
+export * from "./model/AggregateLevel";
+export * from "./model/AnnotationAreaType";
+export * from "./model/annotationTypes";
+export * from "./model/AnnotationType";
+export * from "./model/EventSortableColumn";
+export * from "./model/eventTypes";
+export * from "./model/EventType";
+export * from "./model/healthStatuses";
+export * from "./model/HealthStatus";
+export * from "./model/HexRgbColor";
+export * from "./model/IAnnotationAreaTypeMap";
+export * from "./model/IAnnotation";
+export * from "./model/IBaseEntity";
+export * from "./model/IBaseEvent";
+export * from "./model/IBattery";
+export * from "./model/IBitset";
+export * from "./model/IBoundingBox";
+export * from "./model/ICommandDeliveryEvent";
+export * from "./model/ICommandEventBase";
+export * from "./model/ICommandParameter";
+export * from "./model/ICommandRequestEvent";
+export * from "./model/ICommandRequest";
+export * from "./model/ICommandResponseEvent";
+export * from "./model/ICommandResponse";
+export * from "./model/IComment";
+export * from "./model/IConfigurationMap";
+export * from "./model/ICustomEvent";
+export * from "./model/IDataPoint";
+export * from "./model/IEventFilter";
+export * from "./model/IEventQuery";
+export * from "./model/IEventSort";
+export * from "./model/IEvent";
+export * from "./model/IFieldParametersTypeMap";
+export * from "./model/IFileInfo";
+export * from "./model/IFile";
+export * from "./model/IFilter";
+export * from "./model/IGoalID";
+export * from "./model/IGoal";
+export * from "./model/IHealth";
+export * from "./model/IImageAnnotation";
+export * from "./model/IImage";
+export * from "./model/IInterventionRequest";
+export * from "./model/IInterventionResponse";
+export * from "./model/IInterventionTypeMap";
+export * from "./model/ILabeledPolygon";
+export * from "./model/ILabelingRequestData";
+export * from "./model/ILabelingResponseData";
+export * from "./model/ILabel";
+export * from "./model/ILocalization";
+export * from "./model/ILocation";
+export * from "./model/IMap";
+export * from "./model/interventionTypes";
+export * from "./model/InterventionType";
+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/IRtcSessionRecord";
+export * from "./model/ISelectionRequestData";
+export * from "./model/ISelectionResponseData";
+export * from "./model/ISheetParameters";
+export * from "./model/IsoDate";
+export * from "./model/ISpreadsheetIdRange";
+export * from "./model/IStreamData";
+export * from "./model/IStreamTypeMap";
+export * from "./model/IStreamCurrentValue";
+export * from "./model/ISystemEvent";
+export * from "./model/ITaggedUsers";
+export * from "./model/ITagParameters";
+export * from "./model/ITagSets";
+export * from "./model/ITags";
+export * from "./model/ITeleopRequestData";
+export * from "./model/ITeleopResponseData";
+export * from "./model/ITeleopSessionRecord";
+export * from "./model/ITransformNode";
+export * from "./model/ITransform";
+export * from "./model/ITriggeredEvent";
+export * from "./model/ITwist";
+export * from "./model/IUserParameters";
+export * from "./model/IVector3";
+export * from "./model/IVideo";
+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/videoMimeTypes";
+export * from "./model/VideoMimeType";

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

@@ -0,0 +1,5 @@
+import { accessLevels } from "./accessLevels";
+export declare type AccessLevel = typeof accessLevels[number];
+export declare const viewer: "viewer" | "operator" | "administrator";
+export declare const operator: "viewer" | "operator" | "administrator";
+export declare const administrator: "viewer" | "operator" | "administrator";

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

@@ -0,0 +1 @@
+export declare type AggregateLevel = "year" | "month" | "week" | "day" | "hour" | "minute" | "second";

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

@@ -0,0 +1,2 @@
+import { IAnnotationAreaTypeMap } from "./IAnnotationAreaTypeMap";
+export declare type AnnotationAreaType = keyof IAnnotationAreaTypeMap;

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

@@ -0,0 +1,2 @@
+import { IFieldParametersTypeMap } from "./IFieldParametersTypeMap";
+export declare type AnnotationType = keyof IFieldParametersTypeMap;

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

@@ -0,0 +1 @@
+export declare type EventSortableColumn = "device.name" | "time";

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

@@ -0,0 +1,2 @@
+import { eventTypes } from "./eventTypes";
+export declare type EventType = typeof eventTypes[number];

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

@@ -0,0 +1,2 @@
+import { healthStatuses } from "./healthStatuses";
+export declare type HealthStatus = typeof healthStatuses[number];

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

@@ -0,0 +1 @@
+export declare type HexRgbColor = string;

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

@@ -0,0 +1,13 @@
+import { IBaseEvent } from "./IBaseEvent";
+import { IsoDate } from "./IsoDate";
+import { ISpreadsheetIdRange } from "./ISpreadsheetIdRange";
+import { ITaggedUsers } from "./ITaggedUsers";
+import { Uuid } from "./Uuid";
+export interface IAnnotation extends IBaseEvent<"annotation"> {
+    editedAt?: IsoDate;
+    userId: Uuid;
+    annotationTemplateId: Uuid;
+    taggedUsers?: ITaggedUsers | null;
+    publishedTo?: ISpreadsheetIdRange;
+    note?: string | null;
+}

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

@@ -0,0 +1,4 @@
+import { IBoundingBox } from "./IBoundingBox";
+export interface IAnnotationAreaTypeMap {
+    "bounding box": IBoundingBox;
+}

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

@@ -0,0 +1,7 @@
+import { IsoDate } from "./IsoDate";
+import { Uuid } from "./Uuid";
+export interface IBaseEntity {
+    id?: Uuid;
+    createdAt?: IsoDate;
+    updatedAt?: IsoDate;
+}

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

@@ -0,0 +1,19 @@
+import { EventType } from "./EventType";
+import { IBaseEntity } from "./IBaseEntity";
+import { IsoDate } from "./IsoDate";
+import { ITags } from "./ITags";
+import { StreamType } from "./StreamType";
+import { Uuid } from "./Uuid";
+export interface IBaseEvent<T extends EventType = EventType> extends IBaseEntity {
+    type?: T;
+    organizationId?: Uuid;
+    time: IsoDate;
+    endTime?: IsoDate | null;
+    message: string;
+    viewed?: boolean;
+    deviceId?: Uuid;
+    streamName?: string;
+    streamType?: StreamType;
+    tags?: ITags;
+    notificationEnabled?: boolean;
+}

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

@@ -0,0 +1,6 @@
+export interface IBattery {
+    percentage: number;
+    voltage?: number;
+    current?: number;
+    charge?: number;
+}

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

@@ -0,0 +1,4 @@
+export interface IBitset {
+    keys: string[];
+    values: boolean[];
+}

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

@@ -0,0 +1,6 @@
+export interface IBoundingBox {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}

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

@@ -0,0 +1,3 @@
+import { ICommandEventBase } from "./ICommandEventBase";
+export interface ICommandDeliveryEvent extends ICommandEventBase<"command-delivery"> {
+}

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

@@ -0,0 +1,5 @@
+import { IBaseEvent } from "./IBaseEvent";
+import { Uuid } from "./Uuid";
+export interface ICommandEventBase<T extends "command-request" | "command-delivery" | "command-response"> extends IBaseEvent<T> {
+    commandId: Uuid;
+}

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

@@ -0,0 +1,9 @@
+import { IConfigurationMap } from "./IConfigurationMap";
+import { IFileInfo } from "./IFileInfo";
+import { IsoDate } from "./IsoDate";
+export interface ICommandParameter {
+    value?: string;
+    meta?: IConfigurationMap;
+    scrubberTime: IsoDate;
+    files?: IFileInfo[];
+}

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

@@ -0,0 +1,9 @@
+import { ICommandParameter } from "./ICommandParameter";
+import { IsoDate } from "./IsoDate";
+import { Uuid } from "./Uuid";
+export interface ICommandRequest {
+    id: Uuid;
+    command: string;
+    parameter: ICommandParameter;
+    createdAt: IsoDate;
+}

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

@@ -0,0 +1,5 @@
+import { ICommandEventBase } from "./ICommandEventBase";
+import { Uuid } from "./Uuid";
+export interface ICommandRequestEvent extends ICommandEventBase<"command-request"> {
+    userId?: Uuid;
+}

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

@@ -0,0 +1,13 @@
+import { IsoDate } from "./IsoDate";
+import { ITags } from "./ITags";
+import { StreamType } from "./StreamType";
+import { Uuid } from "./Uuid";
+export interface ICommandResponse {
+    time: IsoDate;
+    message: string;
+    success: boolean;
+    replyToCommandRequestId: Uuid;
+    streamName?: string;
+    streamType?: StreamType;
+    tags?: ITags;
+}

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

@@ -0,0 +1,3 @@
+import { ICommandEventBase } from "./ICommandEventBase";
+export interface ICommandResponseEvent extends ICommandEventBase<"command-response"> {
+}

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

@@ -0,0 +1,7 @@
+import { IBaseEvent } from "./IBaseEvent";
+import { IsoDate } from "./IsoDate";
+import { Uuid } from "./Uuid";
+export interface IComment extends IBaseEvent<"comment"> {
+    editedAt?: IsoDate;
+    userId: Uuid;
+}

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

@@ -0,0 +1,3 @@
+export interface IConfigurationMap {
+    [key: string]: string;
+}

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

@@ -0,0 +1,5 @@
+import { IBaseEvent } from "./IBaseEvent";
+import { Severity } from "./Severity";
+export interface ICustomEvent extends IBaseEvent<"custom"> {
+    severity?: Severity;
+}

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

@@ -0,0 +1,7 @@
+import { IStreamTypeMap } from "./IStreamTypeMap";
+import { StreamType } from "./StreamType";
+import { Timestamp } from "./Timestamp";
+export declare type IDataPoint<T extends StreamType = StreamType> = [
+    Timestamp,
+    IStreamTypeMap[T]
+];

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

@@ -0,0 +1,12 @@
+import { IAnnotation } from "./IAnnotation";
+import { ICommandDeliveryEvent } from "./ICommandDeliveryEvent";
+import { ICommandRequestEvent } from "./ICommandRequestEvent";
+import { ICommandResponseEvent } from "./ICommandResponseEvent";
+import { IComment } from "./IComment";
+import { ICustomEvent } from "./ICustomEvent";
+import { IInterventionRequest } from "./IInterventionRequest";
+import { IPortForwardingSessionRecord } from "./IPortForwardingSessionRecord";
+import { ISystemEvent } from "./ISystemEvent";
+import { ITeleopSessionRecord } from "./ITeleopSessionRecord";
+import { ITriggeredEvent } from "./ITriggeredEvent";
+export declare type IEvent = ITriggeredEvent | IInterventionRequest | ITeleopSessionRecord | IPortForwardingSessionRecord | ICommandRequestEvent | ICommandResponseEvent | ICommandDeliveryEvent | ICustomEvent | IComment | ISystemEvent | IAnnotation;