@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.19

package/models/Token.js

@@ -0,0 +1,78 @@
+import { isNode } from '../helpers/enviroment';
+/** Represents a JWT token.
+ *
+ * @see https://jwt.io/
+ * @see https://tools.ietf.org/html/rfc7519
+ * */
+export class Token {
+    constructor(token, refreshToken) {
+        this.value = token;
+        this.refreshToken = refreshToken;
+        const decoded = this.getJWTPayload(token);
+        this.audience = typeof decoded.aud === 'string' ? decoded.aud : undefined;
+        this.expires = decoded.exp ? new Date(Number(decoded.exp) * 1000) : undefined;
+        this.issuedAt = decoded.iat ? new Date(Number(decoded.iat) * 1000) : undefined;
+        this.issuer = typeof decoded.iss === 'string' ? decoded.iss : undefined;
+        this.subject = typeof decoded.sub === 'string' ? decoded.sub : undefined;
+    }
+    /** Convenience method to get the token in Bearer format. */
+    get bearer() {
+        return `Bearer ${this.value}`;
+    }
+    /**
+     * Check if the token is expired
+     *
+     * You may optionally provide a threshold in minutes to check if the token will expire within that time.
+     * If no threshold is provided, the token will be considered expired if it has already expired.
+     *
+     * @returns true if the token is expired (or will expire within the threshold)
+     */
+    isExpiredIn(threshold = 0, unit = 'minutes') {
+        if (!this.expires) {
+            return false;
+        }
+        const msTillExpire = this.expires.getTime() - Date.now();
+        const msInUnit = {
+            minutes: 60000,
+            seconds: 1000,
+            hours: 3600000,
+        }[unit];
+        return msTillExpire <= threshold * msInUnit;
+    }
+    isExpired() {
+        return this.isExpiredIn();
+    }
+    getJWTPayload(token) {
+        const parts = token.split('.');
+        if (parts.length < 2) {
+            throw new Error('Invalid token, missing payload');
+        }
+        else if (parts.length > 3) {
+            throw new Error('Invalid token, too many parts');
+        }
+        const [header, payload] = parts.slice(0, 2).map((part) => {
+            return JSON.parse(this.decodeBase64(part));
+        });
+        if (typeof payload !== 'object') {
+            throw new Error('Invalid token, payload must be an object');
+        }
+        if (typeof header !== 'object') {
+            throw new Error('Invalid token, header must be an object');
+        }
+        if (!('typ' in header) || header.typ !== 'JWT') {
+            throw new Error('Invalid token, must be a JWT');
+        }
+        return payload;
+    }
+    /** Decode a base64 string.
+     *
+     * Supports both Node.js and browser environments.
+     * @private
+     */
+    decodeBase64(base64String) {
+        if (isNode) {
+            return Buffer.from(base64String, 'base64').toString('utf-8');
+        }
+        return atob(base64String);
+    }
+}

package/models/Token.spec.d.ts

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

package/models/Token.spec.js

@@ -0,0 +1,108 @@
+import { Token } from './Token';
+const generateToken = (config) => {
+    const defaultPayload = {
+        iat: 1234567890,
+        exp: 9876543210,
+        iss: 'myissuer',
+        aud: 'myaudience',
+        sub: 'mysubject',
+    };
+    const encodedHeader = Buffer.from(JSON.stringify(config?.header ?? { alg: 'HS256', typ: 'JWT' })).toString('base64');
+    const encodedPayload = Buffer.from(JSON.stringify(config?.payload ?? defaultPayload)).toString('base64');
+    if (config?.signature === null) {
+        return `${encodedHeader}.${encodedPayload}`;
+    }
+    return `${encodedHeader}.${encodedPayload}.${config?.signature ?? 'signature'}`;
+};
+describe('Token', () => {
+    describe('constructor', () => {
+        it('can get information from a valid token', () => {
+            const token = new Token(generateToken());
+            expect(token.issuedAt).toEqual(new Date(1234567890000));
+            expect(token.expires).toEqual(new Date(9876543210000));
+            expect(token.issuer).toEqual('myissuer');
+            expect(token.audience).toEqual('myaudience');
+            expect(token.subject).toEqual('mysubject');
+        });
+        it('should throw an error for a non-jwt', () => {
+            // completely invalid string
+            expect(() => new Token('not a jwt')).toThrowError('Invalid token');
+            // invalid header
+            expect(() => {
+                new Token(generateToken({
+                    header: {
+                        alg: 'HS256',
+                        typ: 'Not-a-JWT',
+                    },
+                }));
+            }).toThrowError('Invalid token');
+            // too many parts
+            expect(() => {
+                new Token('a.b.c.d');
+            }).toThrowError('Invalid token');
+        });
+        it('should allow a token with no signature', () => {
+            const token = new Token(generateToken({ signature: null }));
+            expect(token.issuedAt).toEqual(new Date(1234567890000));
+            expect(token.expires).toEqual(new Date(9876543210000));
+            expect(token.issuer).toEqual('myissuer');
+            expect(token.audience).toEqual('myaudience');
+            expect(token.subject).toEqual('mysubject');
+        });
+    });
+    describe('isExpired', () => {
+        const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
+        beforeEach(() => {
+            jest.useFakeTimers();
+            jest.setSystemTime(baseDate);
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        const expiredDate = (baseDate.getTime() - 1000 * 60 * 5) / 1000; // 5 minutes ago
+        const notExpiredDate = (baseDate.getTime() + 1000 * 60 * 60 * 24) / 1000; // 1 day from now
+        it('should return true if the token is expired', () => {
+            const token = new Token(generateToken({ payload: { exp: expiredDate } }));
+            expect(token.isExpired()).toEqual(true);
+        });
+        it('should return false if the token is not expired', () => {
+            const token = new Token(generateToken({ payload: { exp: notExpiredDate } }));
+            expect(token.isExpired()).toEqual(false);
+        });
+    });
+    describe('isExpiredIn', () => {
+        const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
+        beforeEach(() => {
+            jest.useFakeTimers();
+            jest.setSystemTime(baseDate);
+        });
+        afterEach(() => {
+            jest.useRealTimers();
+        });
+        const expiredDate = (baseDate.getTime() - 1000 * 60 * 5) / 1000; // 5 minutes ago
+        const expiredIn5MinsDate = (baseDate.getTime() + 1000 * 60 * 5) / 1000; // 5 minutes from now
+        const expiredIn25MinsDate = (baseDate.getTime() + 1000 * 60 * 25) / 1000; // 25 minutes from now
+        const expiredIn2HoursDate = (baseDate.getTime() + 1000 * 60 * 60 * 2) / 1000; // 2 hours from now
+        it('should return true if the token is expired in the given time', () => {
+            const token = new Token(generateToken({ payload: { exp: expiredIn5MinsDate } }));
+            expect(token.isExpiredIn(5, 'minutes')).toEqual(true);
+            expect(token.isExpiredIn(25, 'minutes')).toEqual(true);
+            expect(token.isExpiredIn(2, 'hours')).toEqual(true);
+            const token2 = new Token(generateToken({ payload: { exp: expiredIn25MinsDate } }));
+            expect(token2.isExpiredIn(25, 'minutes')).toEqual(true);
+            expect(token2.isExpiredIn(2, 'hours')).toEqual(true);
+            const token3 = new Token(generateToken({ payload: { exp: expiredDate } }));
+            expect(token3.isExpiredIn(5, 'minutes')).toEqual(true);
+            expect(token3.isExpiredIn(25, 'minutes')).toEqual(true);
+            expect(token3.isExpiredIn(2, 'hours')).toEqual(true);
+        });
+        it('should return false if the token is not expired in the given time', () => {
+            const token = new Token(generateToken({ payload: { exp: expiredIn5MinsDate } }));
+            expect(token.isExpiredIn(4, 'minutes')).toEqual(false);
+            const token2 = new Token(generateToken({ payload: { exp: expiredIn25MinsDate } }));
+            expect(token2.isExpiredIn(24, 'minutes')).toEqual(false);
+            const token3 = new Token(generateToken({ payload: { exp: expiredIn2HoursDate } }));
+            expect(token3.isExpiredIn(1, 'hours')).toEqual(false);
+        });
+    });
+});

package/models/Widget.d.ts

@@ -0,0 +1,27 @@
+import { IWidget } from './IWidget';
+import { IWidgetLineGroup } from './IWidgetLineGroup';
+export declare class Widget implements IWidget {
+    connectionType: string;
+    widgetType: string;
+    widgetHeading: string;
+    dataURI: string;
+    source?: string;
+    units: string;
+    dataName: string;
+    key?: string;
+    valueExpression?: string;
+    decimalPlaces?: number;
+    widgetTimeout?: number;
+    minimumValue: number;
+    maximumValue: number;
+    lineGroups?: IWidgetLineGroup[];
+    rangeMin?: number;
+    rangeMax?: number;
+    tableFormat?: string;
+    videoServer?: string;
+    videoId?: string;
+    videoCommand?: string;
+    videoSourceType?: string;
+    html?: string;
+    constructor(init?: Partial<IWidget>);
+}

package/models/Widget.js

@@ -0,0 +1,12 @@
+import { WidgetLineGroup } from './WidgetLineGroup';
+export class Widget {
+    constructor(init) {
+        Object.assign(this, init);
+        // Line Graph
+        if (init?.lineGroups) {
+            this.lineGroups = init.lineGroups.map((group) => {
+                return new WidgetLineGroup(group);
+            });
+        }
+    }
+}

package/models/WidgetLineGroup.d.ts

@@ -0,0 +1,10 @@
+import { IWidgetLineGroup } from './IWidgetLineGroup';
+export declare class WidgetLineGroup implements IWidgetLineGroup {
+    dataURI: string;
+    source?: string;
+    units: string;
+    dataLabel: string;
+    lineColor: string;
+    valueExpression?: string;
+    constructor(init?: Partial<IWidgetLineGroup>);
+}

package/models/WidgetLineGroup.js

@@ -0,0 +1,5 @@
+export class WidgetLineGroup {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+}

package/models/asset-storage/AssetModelItem.d.ts

@@ -0,0 +1,32 @@
+export interface AssetItemModel {
+    metadata?: {
+        [key: string]: string;
+    };
+    path?: string;
+    contentType?: string;
+    signedURL?: string;
+    name?: string;
+    modifiedTime?: number;
+    size?: number;
+}
+export interface AssetItemWithObservationsModel extends AssetItemModel {
+    observationCount?: number;
+}
+export interface AssetSyncDefinitionModel {
+    path: string;
+    enabled: boolean;
+    deleteFromRobotAfterSync?: boolean;
+    integration?: {
+        forward?: {
+            provider: string;
+            configs: any;
+        }[];
+    };
+}
+export interface AssetSyncDefinitionOverrideModel extends AssetSyncDefinitionModel {
+    _isOverridden: boolean;
+}
+export interface AssetSyncDefinitionsModel {
+    items: AssetSyncDefinitionModel[];
+    profileOverriddenItems?: AssetSyncDefinitionOverrideModel[];
+}

package/models/asset-storage/AssetModelItem.js

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

package/models/caller/IRocosCallerMessageChunk.d.ts

@@ -0,0 +1,10 @@
+import { IRocosCallerMessageResponseAck } from './IRocosCallerMessageResponseAck';
+import { IRocosCallerMessageResponseResult } from './IRocosCallerMessageResponseResult';
+import { IRocosCallerMessageResponseUid } from './IRocosCallerMessageResponseUid';
+export interface IRocosCallerMessageChunk {
+    chunkIndex: number;
+    chunkCount: number;
+    uid?: IRocosCallerMessageResponseUid;
+    ack?: IRocosCallerMessageResponseAck;
+    result?: IRocosCallerMessageResponseResult;
+}

package/models/caller/IRocosCallerMessageChunk.js

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

package/models/caller/IRocosCallerMessageChunks.d.ts

@@ -0,0 +1,4 @@
+import { IRocosCallerMessageChunk } from './IRocosCallerMessageChunk';
+export interface IRocosCallerMessageChunks {
+    chunks: IRocosCallerMessageChunk[];
+}

package/models/caller/IRocosCallerMessageChunks.js

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

package/models/caller/IRocosCallerMessageHeartbeat.d.ts

@@ -0,0 +1,3 @@
+export interface IRocosCallerMessageHeartbeat {
+    [k: string]: never;
+}

package/models/caller/IRocosCallerMessageHeartbeat.js

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

package/models/caller/IRocosCallerMessageResponse.d.ts

@@ -0,0 +1,10 @@
+import { IRocosCallerMessageResponseAck } from './IRocosCallerMessageResponseAck';
+import { IRocosCallerMessageResponseResult } from './IRocosCallerMessageResponseResult';
+import { IRocosCallerMessageResponseReturn } from './IRocosCallerMessageResponseReturn';
+import { IRocosCallerMessageResponseUid } from './IRocosCallerMessageResponseUid';
+export interface IRocosCallerMessageResponse {
+    uid?: IRocosCallerMessageResponseUid;
+    ack?: IRocosCallerMessageResponseAck;
+    result?: IRocosCallerMessageResponseResult;
+    return?: IRocosCallerMessageResponseReturn;
+}

package/models/caller/IRocosCallerMessageResponse.js

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

package/models/caller/IRocosCallerMessageResponseAck.d.ts

@@ -0,0 +1,16 @@
+export declare enum AckStatus {
+    RECEIVED = 0,
+    QUEUED = 1,
+    PROGRESS = 2,
+    CANCELLING = 3
+}
+export declare enum Stage {
+    AGENT = 0,
+    CLOUD_GATEWAY = 1,
+    DEVICE_GATEWAY = 2
+}
+export interface IRocosCallerMessageResponseAck {
+    stage: Stage;
+    status: AckStatus;
+    message: string;
+}

package/models/caller/IRocosCallerMessageResponseAck.js

@@ -0,0 +1,13 @@
+export var AckStatus;
+(function (AckStatus) {
+    AckStatus[AckStatus["RECEIVED"] = 0] = "RECEIVED";
+    AckStatus[AckStatus["QUEUED"] = 1] = "QUEUED";
+    AckStatus[AckStatus["PROGRESS"] = 2] = "PROGRESS";
+    AckStatus[AckStatus["CANCELLING"] = 3] = "CANCELLING";
+})(AckStatus || (AckStatus = {}));
+export var Stage;
+(function (Stage) {
+    Stage[Stage["AGENT"] = 0] = "AGENT";
+    Stage[Stage["CLOUD_GATEWAY"] = 1] = "CLOUD_GATEWAY";
+    Stage[Stage["DEVICE_GATEWAY"] = 2] = "DEVICE_GATEWAY";
+})(Stage || (Stage = {}));

package/models/caller/IRocosCallerMessageResponseResult.d.ts

@@ -0,0 +1,15 @@
+export declare enum ResultStatus {
+    COMPLETE_SUCCESS = 0,
+    CANCELLED = 10,
+    COMPLETE_ERROR = 11,
+    TIMED_OUT = 12,
+    REJECTED_ID = 13,
+    REJECTED_AUTH = 14,
+    REJECTED_PAYLOAD = 15,
+    REJECTED_NO_RECEIVER = 16,
+    FATAL = 17
+}
+export interface IRocosCallerMessageResponseResult {
+    status: ResultStatus;
+    message: string;
+}

package/models/caller/IRocosCallerMessageResponseResult.js

@@ -0,0 +1,12 @@
+export var ResultStatus;
+(function (ResultStatus) {
+    ResultStatus[ResultStatus["COMPLETE_SUCCESS"] = 0] = "COMPLETE_SUCCESS";
+    ResultStatus[ResultStatus["CANCELLED"] = 10] = "CANCELLED";
+    ResultStatus[ResultStatus["COMPLETE_ERROR"] = 11] = "COMPLETE_ERROR";
+    ResultStatus[ResultStatus["TIMED_OUT"] = 12] = "TIMED_OUT";
+    ResultStatus[ResultStatus["REJECTED_ID"] = 13] = "REJECTED_ID";
+    ResultStatus[ResultStatus["REJECTED_AUTH"] = 14] = "REJECTED_AUTH";
+    ResultStatus[ResultStatus["REJECTED_PAYLOAD"] = 15] = "REJECTED_PAYLOAD";
+    ResultStatus[ResultStatus["REJECTED_NO_RECEIVER"] = 16] = "REJECTED_NO_RECEIVER";
+    ResultStatus[ResultStatus["FATAL"] = 17] = "FATAL";
+})(ResultStatus || (ResultStatus = {}));

package/models/caller/IRocosCallerMessageResponseReturn.d.ts

@@ -0,0 +1,8 @@
+export interface IRocosCallerMessageResponseReturn {
+    header?: {
+        createdNs: string;
+        createdAt: Date;
+        meta: Record<string, string>;
+    };
+    payload: Uint8Array;
+}

package/models/caller/IRocosCallerMessageResponseReturn.js

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

package/models/caller/IRocosCallerMessageResponseUid.d.ts

@@ -0,0 +1,10 @@
+export declare enum UIDVersion {
+    /**
+     * The UID is just a random 16 byte number (not a proper GUID).
+     */
+    HEADER_HASH_RAND = 0
+}
+export type IRocosCallerMessageResponseUid = {
+    version: UIDVersion;
+    hash?: string;
+};

package/models/caller/IRocosCallerMessageResponseUid.js

@@ -0,0 +1,7 @@
+export var UIDVersion;
+(function (UIDVersion) {
+    /**
+     * The UID is just a random 16 byte number (not a proper GUID).
+     */
+    UIDVersion[UIDVersion["HEADER_HASH_RAND"] = 0] = "HEADER_HASH_RAND";
+})(UIDVersion || (UIDVersion = {}));

package/models/caller/IRocosCallerMessageResponses.d.ts

@@ -0,0 +1,4 @@
+import { IRocosCallerMessageResponse } from './IRocosCallerMessageResponse';
+export interface IRocosCallerMessageResponses {
+    responses: IRocosCallerMessageResponse[];
+}

package/models/caller/IRocosCallerMessageResponses.js

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

package/models/caller/RocosCallerResultStatus.d.ts

@@ -0,0 +1,11 @@
+export declare enum RocosCallerResultStatus {
+    COMPLETE_SUCCESS = 0,
+    CANCELLED = 10,
+    COMPLETE_ERROR = 11,
+    TIMED_OUT = 12,
+    REJECTED_ID = 13,
+    REJECTED_AUTH = 14,
+    REJECTED_PAYLOAD = 15,
+    REJECTED_NO_RECEIVER = 16,
+    FATAL = 17
+}

package/models/caller/RocosCallerResultStatus.js

@@ -0,0 +1,12 @@
+export var RocosCallerResultStatus;
+(function (RocosCallerResultStatus) {
+    RocosCallerResultStatus[RocosCallerResultStatus["COMPLETE_SUCCESS"] = 0] = "COMPLETE_SUCCESS";
+    RocosCallerResultStatus[RocosCallerResultStatus["CANCELLED"] = 10] = "CANCELLED";
+    RocosCallerResultStatus[RocosCallerResultStatus["COMPLETE_ERROR"] = 11] = "COMPLETE_ERROR";
+    RocosCallerResultStatus[RocosCallerResultStatus["TIMED_OUT"] = 12] = "TIMED_OUT";
+    RocosCallerResultStatus[RocosCallerResultStatus["REJECTED_ID"] = 13] = "REJECTED_ID";
+    RocosCallerResultStatus[RocosCallerResultStatus["REJECTED_AUTH"] = 14] = "REJECTED_AUTH";
+    RocosCallerResultStatus[RocosCallerResultStatus["REJECTED_PAYLOAD"] = 15] = "REJECTED_PAYLOAD";
+    RocosCallerResultStatus[RocosCallerResultStatus["REJECTED_NO_RECEIVER"] = 16] = "REJECTED_NO_RECEIVER";
+    RocosCallerResultStatus[RocosCallerResultStatus["FATAL"] = 17] = "FATAL";
+})(RocosCallerResultStatus || (RocosCallerResultStatus = {}));

package/models/caller/RocosResponseLevel.d.ts

@@ -0,0 +1,6 @@
+export declare enum RocosResponseLevel {
+    ALL = 0,
+    RETURN_AND_RESULT = 1,
+    RESULT_ONLY = 2,
+    NONE = 3
+}

package/models/caller/RocosResponseLevel.js

@@ -0,0 +1,7 @@
+export var RocosResponseLevel;
+(function (RocosResponseLevel) {
+    RocosResponseLevel[RocosResponseLevel["ALL"] = 0] = "ALL";
+    RocosResponseLevel[RocosResponseLevel["RETURN_AND_RESULT"] = 1] = "RETURN_AND_RESULT";
+    RocosResponseLevel[RocosResponseLevel["RESULT_ONLY"] = 2] = "RESULT_ONLY";
+    RocosResponseLevel[RocosResponseLevel["NONE"] = 3] = "NONE";
+})(RocosResponseLevel || (RocosResponseLevel = {}));

package/models/caller/index.d.ts

@@ -0,0 +1,10 @@
+export * from './IRocosCallerMessageChunk';
+export * from './IRocosCallerMessageChunks';
+export * from './IRocosCallerMessageHeartbeat';
+export * from './IRocosCallerMessageResponse';
+export * from './IRocosCallerMessageResponseAck';
+export * from './IRocosCallerMessageResponseResult';
+export * from './IRocosCallerMessageResponses';
+export * from './IRocosCallerMessageResponseUid';
+export * from './RocosCallerResultStatus';
+export * from './RocosResponseLevel';

package/models/caller/index.js

@@ -0,0 +1,10 @@
+export * from './IRocosCallerMessageChunk';
+export * from './IRocosCallerMessageChunks';
+export * from './IRocosCallerMessageHeartbeat';
+export * from './IRocosCallerMessageResponse';
+export * from './IRocosCallerMessageResponseAck';
+export * from './IRocosCallerMessageResponseResult';
+export * from './IRocosCallerMessageResponses';
+export * from './IRocosCallerMessageResponseUid';
+export * from './RocosCallerResultStatus';
+export * from './RocosResponseLevel';

package/models/callsigns/CallsignsEnums.d.ts

@@ -0,0 +1,13 @@
+export declare enum CallsignsLookupType {
+    Query = 0,
+    List = 1
+}
+export declare enum CallsignsLogicalOperation {
+    OR = 0
+}
+export declare enum CallsignsQueryPredicateAttribute {
+    TAG = 0
+}
+export declare enum CallsignsComparisonOperation {
+    EQUAL = 0
+}

package/models/callsigns/CallsignsEnums.js

@@ -0,0 +1,17 @@
+export var CallsignsLookupType;
+(function (CallsignsLookupType) {
+    CallsignsLookupType[CallsignsLookupType["Query"] = 0] = "Query";
+    CallsignsLookupType[CallsignsLookupType["List"] = 1] = "List";
+})(CallsignsLookupType || (CallsignsLookupType = {}));
+export var CallsignsLogicalOperation;
+(function (CallsignsLogicalOperation) {
+    CallsignsLogicalOperation[CallsignsLogicalOperation["OR"] = 0] = "OR";
+})(CallsignsLogicalOperation || (CallsignsLogicalOperation = {}));
+export var CallsignsQueryPredicateAttribute;
+(function (CallsignsQueryPredicateAttribute) {
+    CallsignsQueryPredicateAttribute[CallsignsQueryPredicateAttribute["TAG"] = 0] = "TAG";
+})(CallsignsQueryPredicateAttribute || (CallsignsQueryPredicateAttribute = {}));
+export var CallsignsComparisonOperation;
+(function (CallsignsComparisonOperation) {
+    CallsignsComparisonOperation[CallsignsComparisonOperation["EQUAL"] = 0] = "EQUAL";
+})(CallsignsComparisonOperation || (CallsignsComparisonOperation = {}));

package/models/callsigns/CallsignsLookup.d.ts

@@ -0,0 +1,8 @@
+import { CallsignsLookupType } from './CallsignsEnums';
+import { CallsignsQuery } from './CallsignsQuery';
+export declare class CallsignsLookup {
+    lookupValue: CallsignsQuery | string[];
+    lookupType: CallsignsLookupType;
+    constructor(lookupValue: string[] | CallsignsQuery);
+    toID(): string[];
+}

package/models/callsigns/CallsignsLookup.js

@@ -0,0 +1,28 @@
+import { CallsignsLookupType } from './CallsignsEnums';
+import { CallsignsQuery } from './CallsignsQuery';
+import { arrayUnique } from '../../helpers/arrayUnique';
+export class CallsignsLookup {
+    // Able to lookup the callsigns by list of string array or by query object
+    constructor(lookupValue) {
+        if (lookupValue instanceof CallsignsQuery) {
+            this.lookupType = CallsignsLookupType.Query;
+            this.lookupValue = lookupValue;
+        }
+        else {
+            this.lookupType = CallsignsLookupType.List;
+            // Ensure we always have an instance for lookupValue
+            if (!lookupValue) {
+                this.lookupValue = [];
+            }
+            else {
+                this.lookupValue = arrayUnique(lookupValue).map((item) => item.trim());
+            }
+        }
+    }
+    toID() {
+        if (this.lookupType === CallsignsLookupType.List) {
+            return this.lookupValue.sort();
+        }
+        return [this.lookupValue?.toJSONString()];
+    }
+}

package/models/callsigns/CallsignsQuery.d.ts

@@ -0,0 +1,9 @@
+import { CallsignsLogicalOperation } from './CallsignsEnums';
+import { CallsignsQueryPredicate } from './CallsignsQueryPredicate';
+export declare class CallsignsQuery {
+    operation: CallsignsLogicalOperation;
+    predicates: CallsignsQueryPredicate[];
+    constructor(init?: Partial<CallsignsQuery>);
+    toJSON(): Record<string, any>;
+    toJSONString(): string;
+}

package/models/callsigns/CallsignsQuery.js

@@ -0,0 +1,14 @@
+export class CallsignsQuery {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    toJSON() {
+        return {
+            operation: this.operation,
+            predicates: this.predicates.map((item) => item.toJSON()),
+        };
+    }
+    toJSONString() {
+        return JSON.stringify(this.toJSON());
+    }
+}

package/models/callsigns/CallsignsQueryPredicate.d.ts

@@ -0,0 +1,9 @@
+import { CallsignsComparisonOperation, CallsignsQueryPredicateAttribute } from './CallsignsEnums';
+export declare class CallsignsQueryPredicate {
+    attribute: CallsignsQueryPredicateAttribute;
+    operation: CallsignsComparisonOperation;
+    value: string;
+    constructor(init?: Partial<CallsignsQueryPredicate>);
+    toJSON(): Record<string, any>;
+    toJSONString(): string;
+}

package/models/callsigns/CallsignsQueryPredicate.js

@@ -0,0 +1,15 @@
+export class CallsignsQueryPredicate {
+    constructor(init) {
+        Object.assign(this, init);
+    }
+    toJSON() {
+        return {
+            attribute: this.attribute,
+            operation: this.operation,
+            value: this.value,
+        };
+    }
+    toJSONString() {
+        return JSON.stringify(this.toJSON());
+    }
+}

package/models/command/IRocosCommandMessageHeartbeat.d.ts

@@ -0,0 +1 @@
+export type IRocosCommandMessageHeartbeat = Record<string, never>;

package/models/command/IRocosCommandMessageHeartbeat.js

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