@dronedeploy/rocos-js-sdk 3.0.1-alpha.2 → 3.0.1-alpha.21

package/esm/services/RTPWebRTCService.d.ts

@@ -0,0 +1,102 @@
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { Observable } from 'rxjs';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+export declare enum WebRTCEventType {
+    LoadingTURNConfigs = "loading-turn-configs",
+    Disconnected = "disconnected",
+    DataChannelOpen = "data-channel-open",
+    CreatingOffer = "creating-offer",
+    AddingRemoteTrack = "adding-remote-track",
+    ICEConnectionStateChange = "ice-connection-state-change",
+    SendingOffer = "sending-offer",
+    FailedGettingTURNConfig = "failed-getting-turn-config",
+    GotTURNConfig = "got-turn-config",
+    FailedGettingAnswer = "failed-getting-answer",
+    GotAnswer = "got-answer",
+    DataChannelMessage = "data-channel-message"
+}
+interface EventMetadata {
+    [WebRTCEventType.ICEConnectionStateChange]: {
+        state: RTCIceConnectionState;
+    };
+    [WebRTCEventType.DataChannelMessage]: {
+        label: string;
+        data: string;
+    };
+}
+interface Event<T extends WebRTCEventType> {
+    type: T;
+    metadata: T extends keyof EventMetadata ? EventMetadata[T] : undefined;
+}
+export type WebRTCEvent = {
+    [K in keyof typeof WebRTCEventType]: Event<(typeof WebRTCEventType)[K]>;
+}[keyof typeof WebRTCEventType];
+export interface PeerConnectionParams {
+    projectId: string;
+    callsign: string;
+    logLevel?: 'trace';
+}
+interface InternalPeerConnectionParams extends PeerConnectionParams {
+    endpoint: {
+        host: string;
+        port: number;
+        insecure: boolean;
+    };
+    token: string;
+}
+export declare class RTPWebRTCService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    /** Create a new peer connection with a robot
+     *
+     * To connect, call `connect` on the returned connection
+     *
+     * If `logLevel` is set to trace, the connection will emit all messages as events
+     */
+    createPeerConnection(params: PeerConnectionParams): Promise<WebRTCConnection>;
+}
+export declare class WebRTCConnection {
+    private pc?;
+    private sendChannel?;
+    private readonly endpoint;
+    private readonly token;
+    private readonly projectId;
+    private readonly callsign;
+    private readonly logLevel?;
+    private errorsSubject$;
+    private streamsSubject$;
+    private eventsSubject$;
+    readonly errors$: Observable<Error>;
+    readonly events$: Observable<WebRTCEvent>;
+    readonly streams$: Observable<MediaStream[]>;
+    constructor(params: InternalPeerConnectionParams);
+    get peerConnectionAvailable(): boolean;
+    /** Connect to the robot
+     *
+     * This will create a new peer connection, and send an offer to the robot.
+     * If a connection already exists, it will be disconnected first
+     *
+     * @throws {Error} if the offer fails
+     * @returns {Promise<void>} resolves when the connection is established
+     */
+    connect(): Promise<void>;
+    /**
+     * Disconnect from the robot
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to a video or audio topic
+     *
+     * This will send a message to the robot to start streaming the requested topic.
+     *
+     * Any data received will be sent to the streams emitted by `streams$`
+     */
+    subscribeToTopic(topic: string, type: 'video' | 'audio'): void;
+    private sendOffer;
+    private loadConfig;
+    private createPeerConnection;
+    private getEndpoint;
+    private log;
+}
+export {};

package/esm/services/RTPWebRTCService.js

@@ -0,0 +1,229 @@
+import { RocosError, errorCodes } from '../models';
+import { Subject, scan, shareReplay } from 'rxjs';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosStore } from '../store/RocosStore';
+import { splitRobotTopic } from '../helpers/splitRobotTopic';
+export var WebRTCEventType;
+(function (WebRTCEventType) {
+    WebRTCEventType["LoadingTURNConfigs"] = "loading-turn-configs";
+    WebRTCEventType["Disconnected"] = "disconnected";
+    WebRTCEventType["DataChannelOpen"] = "data-channel-open";
+    WebRTCEventType["CreatingOffer"] = "creating-offer";
+    WebRTCEventType["AddingRemoteTrack"] = "adding-remote-track";
+    WebRTCEventType["ICEConnectionStateChange"] = "ice-connection-state-change";
+    WebRTCEventType["SendingOffer"] = "sending-offer";
+    WebRTCEventType["FailedGettingTURNConfig"] = "failed-getting-turn-config";
+    WebRTCEventType["GotTURNConfig"] = "got-turn-config";
+    WebRTCEventType["FailedGettingAnswer"] = "failed-getting-answer";
+    WebRTCEventType["GotAnswer"] = "got-answer";
+    WebRTCEventType["DataChannelMessage"] = "data-channel-message";
+})(WebRTCEventType || (WebRTCEventType = {}));
+export class RTPWebRTCService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+    }
+    getStatus() {
+        return true;
+    }
+    getError(e) {
+        return new RocosError(e, errorCodes.WEBRTC_SERVICE_ERROR);
+    }
+    /** Create a new peer connection with a robot
+     *
+     * To connect, call `connect` on the returned connection
+     *
+     * If `logLevel` is set to trace, the connection will emit all messages as events
+     */
+    async createPeerConnection(params) {
+        const isInsecure = this.config.insecure ?? false;
+        const port = this.config.port ?? (isInsecure ? 80 : 443);
+        const token = (await RocosStore.getSDKInstance(this.config).getAuthService().getToken()).value;
+        return new WebRTCConnection({
+            endpoint: {
+                host: this.config.url,
+                port,
+                insecure: isInsecure,
+            },
+            token,
+            projectId: params.projectId,
+            callsign: params.callsign,
+            logLevel: params.logLevel,
+        });
+    }
+}
+export class WebRTCConnection {
+    constructor(params) {
+        this.errorsSubject$ = new Subject();
+        this.streamsSubject$ = new Subject();
+        this.eventsSubject$ = new Subject();
+        this.errors$ = this.errorsSubject$.asObservable();
+        this.events$ = this.eventsSubject$.asObservable();
+        this.streams$ = this.streamsSubject$.pipe(scan((streams, stream) => [...streams, stream].filter((i) => i.active), []), shareReplay(1));
+        this.endpoint = params.endpoint;
+        this.token = params.token;
+        this.projectId = params.projectId;
+        this.callsign = params.callsign;
+        this.logLevel = params.logLevel;
+    }
+    get peerConnectionAvailable() {
+        return !!this.pc;
+    }
+    /** Connect to the robot
+     *
+     * This will create a new peer connection, and send an offer to the robot.
+     * If a connection already exists, it will be disconnected first
+     *
+     * @throws {Error} if the offer fails
+     * @returns {Promise<void>} resolves when the connection is established
+     */
+    async connect() {
+        if (this.peerConnectionAvailable)
+            this.disconnect(); // disconnect any lingering connections
+        const config = await this.loadConfig();
+        const pc = this.createPeerConnection(config);
+        this.pc = pc;
+        // Creating data channel, must be done before creating the offer
+        const sendChannel = pc.createDataChannel('submanager');
+        sendChannel.onclose = () => this.log(WebRTCEventType.Disconnected);
+        sendChannel.onopen = () => {
+            this.log(WebRTCEventType.DataChannelOpen);
+        };
+        sendChannel.onmessage = (e) => {
+            this.log(WebRTCEventType.DataChannelMessage, {
+                label: sendChannel.label,
+                data: e.data,
+            });
+        };
+        // Offer to receive 1 audio, and 1 video track
+        pc.addTransceiver('video', { direction: 'recvonly' });
+        pc.addTransceiver('audio', { direction: 'recvonly' });
+        this.log(WebRTCEventType.CreatingOffer);
+        this.sendChannel = sendChannel;
+        await pc.createOffer().then((d) => pc.setLocalDescription(d));
+    }
+    /**
+     * Disconnect from the robot
+     */
+    disconnect() {
+        this.sendChannel?.close();
+        this.pc?.close();
+        this.pc = undefined;
+        this.sendChannel = undefined;
+    }
+    /**
+     * Subscribe to a video or audio topic
+     *
+     * This will send a message to the robot to start streaming the requested topic.
+     *
+     * Any data received will be sent to the streams emitted by `streams$`
+     */
+    subscribeToTopic(topic, type) {
+        if (!this.sendChannel) {
+            throw new Error(`Failed to start ${type}, no data channel available`);
+        }
+        if (!topic || topic.split('/').length < 1) {
+            throw new Error('Invalid Topic Provided');
+        }
+        const { component, topic: path } = splitRobotTopic(topic);
+        this.sendChannel.send(JSON.stringify({
+            projectId: this.projectId,
+            callsign: this.callsign,
+            component,
+            topic: path,
+            token: this.token,
+            logLevel: this.logLevel,
+            type,
+            mode: 'subscribe',
+        }));
+    }
+    async sendOffer(sdp) {
+        return fetch(this.getEndpoint('sdp'), {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+            body: JSON.stringify({
+                sdp,
+            }),
+        })
+            .then((res) => res.json())
+            .catch((err) => {
+            this.log(WebRTCEventType.FailedGettingAnswer);
+            throw new Error(err);
+        })
+            .then((res) => {
+            this.log(WebRTCEventType.GotAnswer);
+            return res;
+        });
+    }
+    async loadConfig() {
+        this.log(WebRTCEventType.LoadingTURNConfigs);
+        return fetch(this.getEndpoint('/sdp/configs'), {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.token}`,
+            },
+        })
+            .then((res) => res.json())
+            .catch((err) => {
+            this.log(WebRTCEventType.FailedGettingTURNConfig);
+            throw new Error(err);
+        })
+            .then((res) => {
+            this.log(WebRTCEventType.GotTURNConfig);
+            return res;
+        });
+    }
+    createPeerConnection(config) {
+        const pc = new RTCPeerConnection(config);
+        this.pc = pc;
+        pc.ontrack = (event) => {
+            if (!document) {
+                this.errorsSubject$.next(new Error('No browser - operation not supported'));
+            }
+            for (const stream of event.streams) {
+                this.streamsSubject$.next(stream);
+            }
+            this.log(WebRTCEventType.AddingRemoteTrack);
+        };
+        pc.oniceconnectionstatechange = () => {
+            this.log(WebRTCEventType.ICEConnectionStateChange, {
+                state: pc.iceConnectionState,
+            });
+            if (pc.iceConnectionState === 'failed') {
+                this.errorsSubject$.next(new Error('ICE Connection Failed'));
+            }
+        };
+        pc.onicecandidate = async (event) => {
+            if (event.candidate === null) {
+                const sdp = btoa(JSON.stringify(pc.localDescription));
+                this.log(WebRTCEventType.SendingOffer);
+                const { answer } = await this.sendOffer(sdp);
+                this.log(WebRTCEventType.GotAnswer);
+                try {
+                    await pc.setRemoteDescription(new RTCSessionDescription(JSON.parse(atob(answer))));
+                }
+                catch (e) {
+                    this.log(WebRTCEventType.FailedGettingAnswer);
+                    console.error('Failed to get answer', e);
+                    this.errorsSubject$.next(new Error('Failed to get answer'));
+                }
+            }
+        };
+        return pc;
+    }
+    getEndpoint(path) {
+        const { host, port, insecure } = this.endpoint;
+        const protocol = insecure ? 'http' : 'https';
+        const base = new URL(`${protocol}://${host}:${port}`);
+        if (path)
+            base.pathname = path;
+        return base.toString();
+    }
+    log(type, metadata) {
+        this.eventsSubject$.next({
+            type,
+            metadata,
+        });
+    }
+}

package/esm/services/RobotService.d.ts

@@ -0,0 +1,278 @@
+import { IBaseService, IRobot, IRobotSettings, IRobotTemplate, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+export declare class RobotService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Get a list of robots.
+     *
+     * @param projectId - Project Id
+     */
+    getRobots(projectId: string): Promise<IRobot[]>;
+    /**
+     * Create a new robot.
+     *
+     * @param projectId
+     * @param robot - Robot payload {@link IRobot}
+     */
+    create(projectId: string, robot: IRobot): Promise<any>;
+    /**
+     * Update robot information.
+     *
+     * @param projectId Project Id
+     * @param robot - Robot payload {@link IRobot}
+     */
+    update(projectId: string, robot: IRobot): Promise<any>;
+    /**
+     * Delete the robots by callsign list
+     *
+     * @param projectId - Project Id
+     * @param callsignIds - Callsign list
+     */
+    delete(projectId: string, callsignIds: string[]): Promise<any>;
+    /**
+     * Get robot information by project id and callsign of the robot.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Callsign of the robot
+     */
+    info(projectId: string, callsign: string): Promise<IRobot>;
+    /**
+     * Get robot information by project id and callsign of the robot.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Callsign of the robot
+     */
+    attributes(projectId: string, callsign: string): Promise<Record<string, string>>;
+    /**
+     * Register the specified callsign
+     *
+     * @param projectId - Project Id
+     * @param callsign - Callsign of the robot
+     */
+    register(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Robot Templates
+     */
+    templates(): Promise<IRobotTemplate[]>;
+    /**
+     * Get the deployment details of virtual robot.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Virtual Robot Callsign
+     */
+    virtualRobotDeploymentDetails(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Deploy a virtual robot by project id and callsign
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot's Callsign
+     */
+    deployVirtualRobot(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Get data sources tree components JSON schema
+     */
+    dataSourcesSchema(): Promise<any>;
+    /**
+     * Delete a robot dashboard.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     * @param dashboardId - Dashboard Id
+     */
+    deleteRobotDashboardsV2(projectId: string, callsign: string, dashboardId: string): Promise<any>;
+    /**
+     * Delete a profile dashboard.
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @param dashboardId - Dashboard Id
+     */
+    deleteDashboardsV2(projectId: string, profileId: string, dashboardId: string): Promise<any>;
+    /**
+     * Get a list of robot dashboards.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     */
+    listRobotDashboardsV2(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Get a list of profile dashboards.
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     */
+    listDashboardsV2(projectId: string, profileId: string): Promise<any>;
+    /**
+     * Get a profile dashboard.
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @param dashboardId - Dashboard Id
+     */
+    robotDefDashboardsV2(projectId: string, profileId: string, dashboardId: string): Promise<any>;
+    /**
+     * Get Dashboard data which stored in Azure Blob.
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @param dashboardId - Dashboard Id
+     */
+    robotDefDashboardBlobV2(projectId: string, profileId: string, dashboardId: string): Promise<any>;
+    /**
+     * Create dashboard for a robot.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     * @param model - Payload
+     */
+    createRobotDashboardsV2(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Create dashboard for a profile.
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @param model - Payload
+     */
+    createDashboardsV2(projectId: string, profileId: string, model: any): Promise<any>;
+    /**
+     * Update dashboard for a profile.
+     *
+     * @param projectId - Project Id
+     * @param profileId - Profile Id
+     * @param dashboardId - Dashboard Id
+     * @param model - Payload
+     */
+    robotDefUpdateDashboardsV2(projectId: string, profileId: string, dashboardId: string, model: any): Promise<any>;
+    /**
+     * Get a list of dashboard for a robot.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     * @param dashboardId - Dashboard Id
+     */
+    getDashboardsV2(projectId: string, callsign: string, dashboardId: string): Promise<any>;
+    /**
+     * Get robot dashboard which stored in Azure Blob.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     * @param dashboardId - Dashboard Id
+     */
+    getDashboardBlobV2(projectId: string, callsign: string, dashboardId: string): Promise<any>;
+    /**
+     * Update dashboard for a robot.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     * @param dashboardId - Dashboard Id
+     * @param model - Payload
+     */
+    updateDashboardsV2(projectId: string, callsign: string, dashboardId: string, model: any): Promise<any>;
+    /**
+     * Get robot settings
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getSettings(projectId: string, callsign: string): Promise<IRobotSettings>;
+    /**
+     * Update robot settings.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    updateSettings(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Get agent settings for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getAgentSettings(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update agent settings for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    updateAgentSettings(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Get commands for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getCommands(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update commands for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    updateCommands(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Get command V2 for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getCommandsV2(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update command V2 for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    updateCommandsV2(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Get buttons for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getButtons(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update buttons for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    updateButtons(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Get triggers for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getTriggers(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update triggers for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - Payload
+     */
+    updateTriggers(projectId: string, callsign: string, model: any): Promise<any>;
+    /**
+     * Get gamepads for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     */
+    getGamepads(projectId: string, callsign: string): Promise<any>;
+    /**
+     * Update gamepads for a robot
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot callsign
+     * @param model - \payload
+     */
+    updateGamepads(projectId: string, callsign: string, model: any): Promise<any>;
+}

package/esm/services/ScheduleService.d.ts

@@ -0,0 +1,22 @@
+import { IBaseService, IRocosSDKConfig, IScheduleInfo, IScheduleInfoUpdate, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+export declare class ScheduleService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    protected getError(e: Error): RocosError;
+    getStatus(): boolean;
+    /**
+     * Get a list of schedules.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     */
+    getSchedules(projectId: string, callsign: string): Promise<IScheduleInfo>;
+    /**
+     * Update schedules.
+     *
+     * @param projectId - Project Id
+     * @param callsign - Robot Callsign
+     * @param schedules - Schedule information
+     */
+    updateSchedules(projectId: string, callsign: string, schedules: IScheduleInfoUpdate): Promise<IScheduleInfo>;
+}

package/esm/services/SearchService.d.ts

@@ -0,0 +1,12 @@
+import { IRocosSDKConfig, IRocosSearchMessage, IRocosSearchStatusMessage, ISearchParams, ISearchQueryParams, ISearchStream, ISearchStreamParams, IStreamConfig } from '../models';
+import { Observable } from 'rxjs';
+import { BaseStreamService } from './BaseStreamService';
+export declare class SearchService extends BaseStreamService<ISearchStream> {
+    constructor(config: IRocosSDKConfig);
+    searchStream(params: ISearchStreamParams): Observable<IRocosSearchMessage[]>;
+    queryData(params: ISearchQueryParams): Promise<string>;
+    healthCheck(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    deleteProjectData(params: ISearchParams): Promise<IRocosSearchStatusMessage>;
+    private createStream;
+    protected getStream(config: IStreamConfig): ISearchStream;
+}

package/esm/services/SearchServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { ISearchStream } from '../models/stream/ISearchStream';
+import { IStreamConfig } from '../models/IStreamConfig';
+import { SearchService } from './SearchService';
+export declare class SearchServiceNode extends SearchService {
+    protected getStream(config: IStreamConfig): ISearchStream;
+}

package/esm/services/SpotProvisioningService.d.ts

@@ -0,0 +1,14 @@
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { Timezone } from '../constants/timezones';
+type SpotImageTag = 'stable' | 'dev' | 'unstable';
+export declare class SpotProvisioningService extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    getSpotCoreImage(projectId: string, profileId: string, robot: {
+        callsign: string;
+        name: string;
+    }, tag?: SpotImageTag, patMetadata?: Record<string, unknown>, timezone?: Timezone): Promise<Blob>;
+}
+export {};

package/esm/services/SpotProvisioningServiceNode.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { Timezone } from '../constants/timezones';
+type SpotImageTag = 'stable' | 'dev' | 'unstable';
+export declare class SpotProvisioningServiceNode extends BaseServiceAbstract implements IBaseService {
+    constructor(config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected getError(e: Error): RocosError;
+    getSpotCoreImage(projectId: string, profileId: string, robot: {
+        callsign: string;
+        name: string;
+    }, tag?: SpotImageTag, patMetadata?: Record<string, unknown>, timezone?: Timezone): Promise<NodeJS.ReadableStream>;
+}
+export {};