@formant/data-sdk 1.2.0 → 1.3.1

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

@@ -0,0 +1,10 @@
+import { IAccount } from "./model/IAccount";
+import { IAccountTree } from "./model/IAccountTree";
+export declare class Account {
+    static listAccounts(): Promise<IAccount[]>;
+    static createAccounts(account: IAccount): Promise<IAccount>;
+    static getAccount(id: string): Promise<IAccount>;
+    static patchAccount(id: string, account: Partial<Account>): Promise<IAccount>;
+    static deleteAccount(id: string): Promise<void>;
+    static getAccountTree(id: string): Promise<IAccountTree>;
+}

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

@@ -1,4 +1,4 @@
-import { RtcClient, RtcClientV1 } from "@formant/realtime-sdk";
+import { RtcClient } from "@formant/realtime-sdk";
 import { SessionType } from "./model/SessionType";
 import { RtcClientPool } from "./utils/RtcClientPool";
 export declare const AppRtcClientPools: {
@@ -12,9 +12,7 @@ export declare const AppRtcClientPools: {
     readonly 3: RtcClientPool<RtcClient>;
 };
 export declare const defaultRtcClientPool: RtcClientPool<RtcClient>;
-export declare const v1RtcClientPool: RtcClientPool<RtcClientV1>;
 export declare const getRtcClientPool: (options: {
-    version: string;
     sessionType?: SessionType;
-}) => RtcClientPool<RtcClient> | RtcClientPool<RtcClientV1>;
+}) => RtcClientPool<RtcClient>;
 export declare function debug(): void;

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

@@ -1,5 +1,6 @@
 import { IRtcStreamMessage } from "@formant/realtime-sdk";
-import { Device, RealtimeDataStream } from "./Device";
+import { Device } from "./Device";
+import { RealtimeDataStream } from "./BaseDevice";
 export declare class AudioPlayer {
     private device;
     private stream;

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

@@ -0,0 +1,129 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { IRtcSendConfiguration, IRtcStreamMessage, IRtcStreamPayload, RtcClient } from "@formant/realtime-sdk";
+import { ITags } from "./model/ITags";
+import { Uuid } from "./model/Uuid";
+import { SessionType } from "./model/SessionType";
+import { DataChannel } from "./DataChannel";
+import { RtcStreamType } from "@formant/realtime-sdk/dist/model/RtcStreamType";
+import { EventEmitter } from "events";
+import { Manipulator } from "./Manipulator";
+import { BinaryRequestDataChannel, TextRequestDataChannel } from "./main";
+import { IRtcPeer } from "@formant/realtime-sdk/dist/model/IRtcPeer";
+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;
+}
+export declare abstract class BaseDevice extends EventEmitter {
+    rtcClient: RtcClient | undefined;
+    remoteDevicePeerId: string | null;
+    protected realtimeListeners: RealtimeListener[];
+    protected connectionMonitorInterval: NodeJS.Timeout | undefined;
+    abstract getConfiguration(): Promise<ConfigurationDocument>;
+    abstract startRealtimeConnection(sessionType?: number): Promise<void>;
+    abstract getRemotePeer(): Promise<IRtcPeer>;
+    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/Device.d.ts

@@ -1,13 +1,5 @@
-/// <reference types="node" />
-import { EventEmitter } from "events";
-import { IRtcSendConfiguration, IRtcStreamMessage, IRtcStreamPayload, RtcClient, RtcClientV1 } from "@formant/realtime-sdk";
-import { RtcStreamType } from "@formant/realtime-sdk/dist/model/RtcStreamType";
 import { IRtcPeer } from "@formant/realtime-sdk/dist/model/IRtcPeer";
-import { DataChannel } from "./DataChannel";
 import { CaptureStream } from "./CaptureStream";
-import { Manipulator } from "./Manipulator";
-import { TextRequestDataChannel, BinaryRequestDataChannel } from "./RequestDataChannel";
-import { Uuid } from "./model/Uuid";
 import { InterventionType } from "./model/InterventionType";
 import { IInterventionTypeMap } from "./model/IInterventionTypeMap";
 import { IInterventionResponse } from "./model/IInterventionResponse";
@@ -15,119 +7,19 @@ import { IEventQuery } from "./model/IEventQuery";
 import { AggregateLevel } from "./model/AggregateLevel";
 import { EventType } from "./model/EventType";
 import { IShare } from "./model/IShare";
-import { ITags } from "./model/ITags";
 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;
-};
-interface IStartRealtimeConnectionOptions {
-    sessionType?: SessionType;
-    deadlineMs?: number;
-    maxConnectRetries?: number;
-}
-export interface IRealtimeDevice {
-    startRealtimeConnection(sessionType?: number): 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 extends EventEmitter implements IRealtimeDevice {
+import { BaseDevice, Command, ConfigurationDocument, IStartRealtimeConnectionOptions, TelemetryStream } from "./BaseDevice";
+import { ITags } from "./model/ITags";
+import { IDevice } from "./model/IDevice";
+export declare class Device extends BaseDevice {
     id: string;
     name: string;
     private organizationId;
     tags?: ITags | undefined;
-    rtcClient: RtcClient | RtcClientV1 | undefined;
-    remoteDevicePeerId: string | null;
-    realtimeListeners: RealtimeListener[];
-    private connectionMonitorInterval;
     constructor(id: string, name: string, organizationId: string, tags?: ITags | undefined);
     getLatestTelemetry(): Promise<any>;
     getConfiguration(): Promise<ConfigurationDocument>;
     getFileUrl(fileId: string): Promise<string[]>;
-    private handleMessage;
-    getRealtimeStatus(): "disconnected" | "connecting" | "connected";
-    getRealtimePing(): number | undefined;
     /**
      * Starts a real-time connection with the remote device using WebRTC.
      * @param {number} [options] - Optional session type to be used for the connection.
@@ -137,30 +29,12 @@ export declare class Device extends EventEmitter implements IRealtimeDevice {
     startRealtimeConnection(options?: SessionType | IStartRealtimeConnectionOptions): Promise<void>;
     private getRemoteDevicePeerId;
     private initConnectionMonitoring;
-    private isV2Signaling;
-    private stopConnectionMonitoring;
-    sendRealtimeMessage(message: IRtcStreamMessage, config?: IRtcSendConfiguration): Promise<void>;
-    addRealtimeListener(listener: RealtimeListener): void;
-    removeRealtimeListener(listener: RealtimeListener): void;
-    getRealtimeAudioStreams(): Promise<RealtimeAudioStream[]>;
-    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>;
-    changeStreamAudioType(streamName: string, newFormat: "wav" | "opus"): Promise<void>;
-    disableRealtimeTelemetryPriorityIngestion(streamName: string): Promise<void>;
     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>;
-    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[];
@@ -184,6 +58,6 @@ export declare class Device extends EventEmitter implements IRealtimeDevice {
         events: import("./main").IEvent[];
     }[]>;
     createShareLink(share: IShare, view: string): Promise<string | null>;
-    private getRemotePeerId;
+    createDevice(device: IDevice): Promise<IDevice>;
+    patchDevice(id: string, device: Partial<IDevice>): Promise<IDevice>;
 }
-export {};

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

@@ -19,6 +19,7 @@ import { IStreamTypeMap } from "./model/IStreamTypeMap";
 import { ITaskReportColumn } from "./model/ITaskReportColumn";
 import { IView } from "./model/IView";
 import { PeerDevice } from "./PeerDevice";
+import { IFleet } from "./model/IFleet";
 export interface TelemetryResult {
     deviceId: string;
     name: string;
@@ -205,4 +206,11 @@ export declare class Fleet {
      *   });
      */
     static createShareLink(share: IShare, view: string): Promise<string | null>;
+    static listFleets(): Promise<IFleet[]>;
+    static createFleet(fleet: IFleet): Promise<IFleet>;
+    static getFleet(id: string): Promise<IFleet>;
+    static patchFleet(id: string, role: Partial<IFleet>): Promise<IFleet>;
+    static deleteFleet(id: string): Promise<void>;
+    static addDeviceToFleet(deviceId: string, fleetId: string): Promise<any>;
+    static getFleetDevices(id: string): Promise<void>;
 }

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

@@ -1,5 +1,6 @@
+import { ITagSets } from "./main";
 export declare class KeyValue {
-    static set(key: string, value: string): Promise<void>;
+    static set(key: string, value: string, tags?: ITagSets): Promise<void>;
     static get(key: string): Promise<string>;
     static list(): Promise<string[]>;
     static delete(key: string): Promise<void>;

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

@@ -1,4 +1,4 @@
-import { RealtimeDataStream, IJointState, RealtimeMessage, IRealtimeDevice } from "./Device";
+import { RealtimeDataStream, IJointState, RealtimeMessage, BaseDevice } from "./BaseDevice";
 export type RealtimeManipulatorConfig = {
     currentJointStateStream: RealtimeDataStream;
     plannedJointStateStream?: RealtimeDataStream;
@@ -12,7 +12,7 @@ export declare class Manipulator {
     private device;
     private config;
     currentListeners: ((js: IJointState) => void)[];
-    constructor(device: IRealtimeDevice, config: RealtimeManipulatorConfig);
+    constructor(device: BaseDevice, config: RealtimeManipulatorConfig);
     synchronize(): Promise<void>;
     desynchronize(): Promise<void>;
     onRealtimeMessage: (_peerId: string, message: RealtimeMessage) => void;

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

@@ -1,37 +1,19 @@
-import { 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 {
+import { BaseDevice, ConfigurationDocument } from "./BaseDevice";
+export declare class PeerDevice extends BaseDevice {
     peerUrl: string;
-    rtcClient: RtcClient | undefined;
-    remoteDevicePeerId: string | undefined;
-    realtimeListeners: RealtimeListener[];
     id: string;
+    private telemetryStreamActive;
+    private streamTelemetry;
     constructor(peerUrl: string);
     getLatestTelemetry(): Promise<IStreamCurrentValue[]>;
+    private subscribeToTelemetry;
+    private readNextTelemetryRecord;
     getDeviceId(): Promise<string>;
     getConfiguration(): Promise<ConfigurationDocument>;
-    private handleMessage;
-    getRealtimeStatus(): "disconnected" | "connecting" | "connected";
-    getRealtimePing(): number | undefined;
     startRealtimeConnection(sessionType?: number): 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>;
+    private initConnectionMonitoring;
     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

@@ -1,12 +1,12 @@
 import { DataChannel, DataChannelErrorListener, DataChannelListener } from "./main";
-import { IRealtimeDevice } from "./Device";
+import { BaseDevice } from "./BaseDevice";
 declare abstract class RequestDataChannel {
-    protected device: IRealtimeDevice;
+    protected device: BaseDevice;
     protected channel_name: string;
     protected timeout: number;
     protected channel: undefined | DataChannel;
     protected requestIdToResponseMap: Map<string, any>;
-    constructor(device: IRealtimeDevice, channel_name: string, timeout: number);
+    constructor(device: BaseDevice, channel_name: string, timeout: number);
     addOpenListener(listener: DataChannelListener): void;
     removeOpenListener(listener: DataChannelListener): void;
     addCloseListener(listener: DataChannelListener): void;

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

@@ -0,0 +1,8 @@
+import { IRole } from "./model/IRole";
+export declare class Role {
+    static listRoles(): Promise<IRole[]>;
+    static createRole(role: IRole): Promise<IRole>;
+    static getRole(id: string): Promise<IRole>;
+    static patchRole(id: string, role: Partial<IRole>): Promise<IRole>;
+    static deleteRole(id: string): Promise<void>;
+}

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

@@ -0,0 +1,8 @@
+import { IUser } from "./model/IUser";
+export declare class User {
+    static listUsers(): Promise<IUser[]>;
+    static createUser(user: IUser): Promise<IUser>;
+    static getUser(id: string): Promise<IUser>;
+    static patchUser(id: string, user: Partial<IUser>): Promise<IUser>;
+    static deleteUser(id: string): Promise<void>;
+}

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

@@ -1,15 +1,23 @@
-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 "./utils";
-export * from "./AudioPlayer";
+export { App } from "./App";
+export { Fleet } from "./Fleet";
+export { Authentication } from "./Authentication";
+export { Device } from "./Device";
+export { PeerDevice } from "./PeerDevice";
+export { DataChannel } from "./DataChannel";
+export { CaptureStream } from "./CaptureStream";
+export { Manipulator } from "./Manipulator";
+export { BinaryRequestDataChannel, TextRequestDataChannel, } from "./RequestDataChannel";
+export { KeyValue } from "./KeyValue";
+export { AudioPlayer } from "./AudioPlayer";
+export { Account } from "./Account";
+export { Role } from "./Role";
+export { User } from "./User";
+export type { AppMessage, DataPoint, EmbeddedAppMessage, IDevice, ModuleConfigurationMessage, ModuleData, QueryRange, Stream, StreamData, } from "./App";
+export type { TelemetryResult } from "./Fleet";
+export type { Command, ConfigurationDocument, IAdapterConfiguration, IJointState, IStartRealtimeConnectionOptions, RealtimeAudioStream, RealtimeDataStream, RealtimeListener, RealtimeMessage, RealtimeVideoStream, TelemetryStream, } from "./BaseDevice";
+export type { DataChannelBinaryListener, DataChannelErrorListener, DataChannelListener, DataChannelStringListener, } from "./DataChannel";
+export type { CaptureSession } from "./CaptureStream";
+export type { RealtimeManipulatorConfig } from "./Manipulator";
 export * from "./model/accessLevels";
 export * from "./model/AccessLevel";
 export * from "./model/aggregateLevels";

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

@@ -0,0 +1,2 @@
+import { cognitoRegions } from "./cognitoRegions";
+export type CognitoRegion = (typeof cognitoRegions)[number];

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

@@ -0,0 +1,7 @@
+import { IBaseEntity } from "./IBaseEntity";
+import { Uuid } from "./Uuid";
+export interface IAccount extends IBaseEntity {
+    organizationId?: Uuid;
+    name: string;
+    parentId: Uuid | null;
+}

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

@@ -0,0 +1,4 @@
+import { IAccount } from "./IAccount";
+export interface IAccountTree extends IAccount {
+    children?: IAccountTree[];
+}

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

@@ -0,0 +1,4 @@
+export interface IAudioDevice {
+    id: string;
+    name: string;
+}

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

@@ -0,0 +1,5 @@
+export interface ICommandProgress {
+    commandId: string;
+    progress: number;
+    pending: boolean;
+}

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

@@ -0,0 +1,31 @@
+import { ITaggedEntity } from "./ITaggedEntity";
+import { Uuid } from "./Uuid";
+import { IScopeFilter } from "./IScopeFilter";
+import { IsoDate } from "./IsoDate";
+import { DeviceType } from "./DeviceType";
+import { IDeviceScope } from "./IDeviceScope";
+import { IDeviceState } from "./IDeviceState";
+import { IDeviceFollower } from "./IdeviceFollower";
+export interface IDevice extends ITaggedEntity {
+    organizationId?: Uuid;
+    name: string;
+    type?: DeviceType;
+    userId?: Uuid | null;
+    fleetId?: Uuid | null;
+    eventTriggerGroupId?: Uuid | null;
+    scope?: IScopeFilter | null;
+    deviceScope?: IDeviceScope;
+    publicKey: string;
+    desiredAgentVersion?: string | null;
+    desiredConfigurationVersion?: number | null;
+    temporaryConfigurationVersion?: number | null;
+    temporaryConfigurationExpiration?: IsoDate | null;
+    temporaryConfigurationTemplateId?: Uuid | null;
+    followers?: IDeviceFollower[];
+    slackChannels?: string[];
+    phoneNumber?: string;
+    state?: IDeviceState;
+    enabled?: boolean;
+    fullyConfigured?: boolean;
+    disabledAt?: IsoDate | null;
+}

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

@@ -0,0 +1,3 @@
+export interface IDeviceReportedConfigurationState {
+    version: number | null;
+}

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

@@ -0,0 +1,4 @@
+import { IRosTopic } from "./IRosTopic";
+export interface IDeviceRosState {
+    topics: IRosTopic[];
+}

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

@@ -0,0 +1,5 @@
+import { IScopeFilter } from "./IScopeFilter";
+export interface IDeviceScope extends IScopeFilter {
+    views?: IScopeFilter;
+    commands?: IScopeFilter;
+}

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

@@ -0,0 +1,16 @@
+import { IDeviceReportedConfigurationState } from "./IDeviceReportedConfigurationState";
+import { IHwInfo } from "./IHwInfo";
+import { IDeviceRosState } from "./IDeviceRosState";
+import { IDictionary } from "./IDictionary";
+import { IOnDemandState } from "./IOnDemandState";
+import { ICommandProgress } from "./ICommandPropgress";
+export interface IDeviceState {
+    agentVersion?: string | null;
+    reportedConfiguration?: IDeviceReportedConfigurationState | null;
+    hwInfo?: IHwInfo | null;
+    ros?: IDeviceRosState | null;
+    env?: IDictionary | null;
+    otaEnabled?: boolean | null;
+    onDemand?: IOnDemandState | null;
+    commandProgress?: ICommandProgress[] | null;
+}

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

@@ -0,0 +1,3 @@
+export interface IDictionary<T = string> {
+    [key: string]: T;
+}

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

@@ -0,0 +1,8 @@
+import { IDeviceScope } from "./IDeviceScope";
+import { ITaggedEntity } from "./ITaggedEntity";
+import { Uuid } from "./Uuid";
+export interface IFleet extends ITaggedEntity {
+    organizationId?: Uuid;
+    name: string;
+    scope?: IDeviceScope;
+}

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

@@ -0,0 +1,17 @@
+import { IAudioDevice } from "./IAudioInfo";
+import { IKernelInfo } from "./IKernelInfo";
+import { INetworkInfo } from "./InetworkInfo";
+import { INodeInfo } from "./INodeInfo";
+import { IOnvifDevice } from "./IOnvifDevice";
+import { IOsInfo } from "./IOsInfo";
+import { IVideoDevice } from "./IVideoDevice";
+export interface IHwInfo {
+    hwEncodingAvailable?: boolean;
+    nodeInfo?: INodeInfo;
+    kernelInfo?: IKernelInfo;
+    osInfo?: IOsInfo;
+    networkInfo?: INetworkInfo;
+    videoDevices?: IVideoDevice[];
+    audioCaptureDevices?: IAudioDevice[];
+    onvifDevices?: IOnvifDevice[];
+}

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

@@ -0,0 +1,5 @@
+export interface IKernelInfo {
+    release?: string;
+    version?: string;
+    architecture?: string;
+}

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

@@ -0,0 +1,4 @@
+export interface INetwork {
+    name?: string;
+    ip4?: string;
+}