@dronedeploy/rocos-js-sdk 3.0.9 → 3.0.11

package/cjs/helpers/kscript/kscript.d.ts

@@ -1,6 +1,11 @@
 import { ContextOptions, PrototypeWhitelist, Scope } from './Context';
 import { Node } from './nodes';
-export declare function execute(code: string, scope?: Scope, options?: ContextOptions): unknown;
-export declare function compile(code: string, scope?: Scope, options?: ContextOptions): Node;
+export declare const compile: (code: string, scope?: Scope, options?: ContextOptions) => Node;
+/** Throws an error if the code uses an invalid node.
+ *
+ * This does not check that the code will run without errors, only that the nodes used are allowed.
+ **/
+export declare const validate: (code: string, options?: ContextOptions) => void;
+export declare const execute: (code: string, scope?: Scope, options?: ContextOptions) => unknown;
 export declare const SAFE_GLOBALS: Map<string, unknown>;
 export declare const SAFE_PROTOTYPES: PrototypeWhitelist;

package/cjs/helpers/kscript/kscript.js

@@ -3,36 +3,46 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SAFE_PROTOTYPES = exports.SAFE_GLOBALS = exports.compile = exports.execute = void 0;
+exports.SAFE_PROTOTYPES = exports.SAFE_GLOBALS = exports.execute = exports.validate = exports.compile = void 0;
 const Context_1 = __importDefault(require("./Context"));
 const acorn_1 = require("acorn");
 const utils_1 = require("./utils");
-function execute(code, scope, options) {
-    return compile(code, scope, options).run();
-}
-exports.execute = execute;
-function compile(code, scope, options) {
-    let program;
+const parse = (code) => {
     try {
         // we add the brackets to ensure that object literals are parsed correctly
-        program = (0, acorn_1.parse)(`(${code})`, { ecmaVersion: 2020, sourceType: 'script' });
+        // e.g. `{ a: 1 }` is not a valid statement, but `({ a: 1 })` is
+        return (0, acorn_1.parse)(`(${code})`, { ecmaVersion: 2020, sourceType: 'script' });
     }
     catch (error) {
         if (error instanceof SyntaxError) {
             // fallback to non-wrapped code for edge cases where the brackets cause issues
-            program = (0, acorn_1.parse)(`${code}`, { ecmaVersion: 2020, sourceType: 'script' });
-        }
-        else {
-            throw error;
+            // e.g. `if (a) 2; else 4;` will throw a syntax error if wrapped in brackets
+            return (0, acorn_1.parse)(`${code}`, { ecmaVersion: 2020, sourceType: 'script' });
         }
+        throw error;
     }
+};
+const compile = (code, scope, options) => {
+    const program = parse(code);
     const context = new Context_1.default(scope ?? exports.SAFE_GLOBALS, {
         prototypeWhitelist: exports.SAFE_PROTOTYPES,
         ...options,
     });
     return (0, utils_1.construct)(program, context);
-}
+};
 exports.compile = compile;
+/** Throws an error if the code uses an invalid node.
+ *
+ * This does not check that the code will run without errors, only that the nodes used are allowed.
+ **/
+const validate = (code, options) => {
+    (0, exports.compile)(code, undefined, options).validate(true);
+};
+exports.validate = validate;
+const execute = (code, scope, options) => {
+    return (0, exports.compile)(code, scope, options).run();
+};
+exports.execute = execute;
 exports.SAFE_GLOBALS = new Map(Object.entries({
     console: {
         debug: console.debug,

package/cjs/helpers/kscript/nodes/Identifier.d.ts

@@ -8,5 +8,6 @@ import Node from './Node';
  */
 export default class IdentifierNode extends Node<Identifier> {
     constructor(node: AnyNode, context: Context);
+    validate(): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/Identifier.js

@@ -13,6 +13,7 @@ class IdentifierNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'Identifier');
     }
+    validate() { }
     run() {
         return this.scope.get(this.node.name);
     }

package/cjs/helpers/kscript/nodes/Literal.d.ts

@@ -7,5 +7,6 @@ import Node from './Node';
  */
 export default class LiteralNode extends Node<Literal> {
     constructor(node: AnyNode, context: Context);
+    validate(): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/Literal.js

@@ -12,10 +12,13 @@ class LiteralNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'Literal');
     }
-    run() {
+    validate() {
         if (this.node.bigint) {
             throw new Error('BigInts are not supported');
         }
+    }
+    run() {
+        this.validate();
         return this.node.value;
     }
 }

package/cjs/helpers/kscript/nodes/Node.d.ts

@@ -5,5 +5,11 @@ export default abstract class Node<T extends AnyNode = AnyNode> {
     protected node: T;
     protected scope: Context['scope'];
     protected constructor(node: AnyNode, context: Context, expectedType: T['type'] | T['type'][]);
+    /** Runs the node. */
     abstract run(): unknown;
+    /** Validates the node. If the node is invalid, an error is thrown.
+     *
+     * if `validateChildren` is true, the children of the node will also be validated.
+     */
+    abstract validate(validateChildren: boolean): void;
 }

package/cjs/helpers/kscript/nodes/Program.d.ts

@@ -7,5 +7,6 @@ import Node from './Node';
  */
 export default class ProgramNode extends Node<Program> {
     constructor(node: AnyNode, scope: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/Program.js

@@ -13,12 +13,18 @@ class ProgramNode extends Node_1.default {
     constructor(node, scope) {
         super(node, scope, 'Program');
     }
-    run() {
-        const children = this.node.body;
-        if (children.length !== 1) {
+    validate(validateChildren = false) {
+        if (this.node.body.length !== 1) {
             throw new Error('Only a single statement is supported in the sandbox');
         }
-        return (0, utils_1.construct)(children[0], this.context).run();
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.body[0], this.context).validate(true);
+    }
+    run() {
+        this.validate();
+        return (0, utils_1.construct)(this.node.body[0], this.context).run();
     }
 }
 exports.default = ProgramNode;

package/cjs/helpers/kscript/nodes/TemplateLiteral.d.ts

@@ -19,5 +19,6 @@ import Node from './Node';
  */
 export default class TemplateLiteralNode extends Node<TemplateLiteral> {
     constructor(node: AnyNode, scope: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/TemplateLiteral.js

@@ -25,6 +25,14 @@ class TemplateLiteralNode extends Node_1.default {
     constructor(node, scope) {
         super(node, scope, 'TemplateLiteral');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const expression of this.node.expressions) {
+            (0, utils_1.construct)(expression, this.context).validate(true);
+        }
+    }
     run() {
         return this.node.quasis.reduce((acc, quasi, i) => {
             const expression = this.node.expressions[i] ? (0, utils_1.construct)(this.node.expressions[i], this.context).run() : '';

package/cjs/helpers/kscript/nodes/expressions/ArrayExpression.d.ts

@@ -3,5 +3,6 @@ import type Context from '../../Context';
 import Node from '../Node';
 export default class ArrayExpressionNode extends Node<ArrayExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ArrayExpression.js

@@ -9,6 +9,17 @@ class ArrayExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'ArrayExpression');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        for (const element of this.node.elements) {
+            if (element === null) {
+                continue;
+            }
+            (0, utils_1.construct)(element, this.context).validate(true);
+        }
+    }
     run() {
         const array = [];
         for (const element of this.node.elements) {

package/cjs/helpers/kscript/nodes/expressions/ArrowFunctionExpression.d.ts

@@ -10,5 +10,6 @@ import Node from '../Node';
 export default class ArrowFunctionExpressionNode extends Node<ArrowFunctionExpression> {
     private readonly params;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ArrowFunctionExpression.js

@@ -19,13 +19,20 @@ class ArrowFunctionExpressionNode extends Node_1.default {
         }
         this.params = this.node.params;
     }
-    run() {
+    validate(validateChildren = false) {
         if (!this.context.isFunctionCallAllowed)
             throw new Error('functions are not allowed');
         if (!this.node.expression)
             throw new Error('functions must be an expression');
         if (this.node.async)
             throw new Error('async functions are not supported');
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.body, this.context).validate(true);
+    }
+    run() {
+        this.validate();
         return (...args) => {
             const scope = new Map();
             for (const param of this.params) {

package/cjs/helpers/kscript/nodes/expressions/BinaryExpression.d.ts

@@ -6,7 +6,13 @@ import Node from '../Node';
  * e.g. `1 + 2`, `a === b`, `c < d`
  */
 export default class BinaryExpressionNode extends Node<BinaryExpression> {
+    private static readonly EQUALITY_OPERATORS;
+    private static readonly COMPARISON_OPERATORS;
+    private static readonly ARITHMETIC_OPERATORS;
+    private static readonly IN_OPERATOR;
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     private operate;
     private arithmetic;

package/cjs/helpers/kscript/nodes/expressions/BinaryExpression.js

@@ -13,35 +13,35 @@ class BinaryExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'BinaryExpression');
     }
+    validate(validateChildren = false) {
+        if (!BinaryExpressionNode.SUPPORTED_OPERATORS.has(this.node.operator)) {
+            throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.left, this.context).validate(true);
+        (0, utils_1.construct)(this.node.right, this.context).validate(true);
+    }
     run() {
         const left = (0, utils_1.construct)(this.node.left, this.context).run();
         const right = (0, utils_1.construct)(this.node.right, this.context).run();
         return this.operate(left, right);
     }
     operate(left, right) {
-        switch (this.node.operator) {
-            case '==':
-            case '!=':
-            case '===':
-            case '!==':
-                return this.equality(this.node.operator, left, right);
-            case '<':
-            case '<=':
-            case '>':
-            case '>=':
-                return this.comparison(this.node.operator, left, right);
-            case 'in':
-                return this.checkIn(left, right);
-            case '**':
-            case '+':
-            case '-':
-            case '*':
-            case '/':
-            case '%':
-                return this.arithmetic(this.node.operator, left, right);
-            default:
-                throw new Error(`Unsupported operator: ${this.node.operator}`);
+        if (BinaryExpressionNode.EQUALITY_OPERATORS.has(this.node.operator)) {
+            return this.equality(this.node.operator, left, right);
+        }
+        if (BinaryExpressionNode.COMPARISON_OPERATORS.has(this.node.operator)) {
+            return this.comparison(this.node.operator, left, right);
+        }
+        if (BinaryExpressionNode.ARITHMETIC_OPERATORS.has(this.node.operator)) {
+            return this.arithmetic(this.node.operator, left, right);
+        }
+        if (this.node.operator === BinaryExpressionNode.IN_OPERATOR) {
+            return this.checkIn(left, right);
         }
+        throw new Error(`Unsupported operator: ${this.node.operator}`);
     }
     arithmetic(operator, left, right) {
         if (operator === '+' && (typeof left === 'string' || typeof right === 'string')) {
@@ -101,4 +101,21 @@ class BinaryExpressionNode extends Node_1.default {
         return right.includes(left);
     }
 }
+BinaryExpressionNode.EQUALITY_OPERATORS = new Set(['==', '!=', '===', '!==']);
+BinaryExpressionNode.COMPARISON_OPERATORS = new Set(['<', '<=', '>', '>=']);
+BinaryExpressionNode.ARITHMETIC_OPERATORS = new Set([
+    '+',
+    '-',
+    '*',
+    '/',
+    '%',
+    '**',
+]);
+BinaryExpressionNode.IN_OPERATOR = 'in';
+BinaryExpressionNode.SUPPORTED_OPERATORS = new Set([
+    ...BinaryExpressionNode.EQUALITY_OPERATORS,
+    ...BinaryExpressionNode.COMPARISON_OPERATORS,
+    ...BinaryExpressionNode.ARITHMETIC_OPERATORS,
+    BinaryExpressionNode.IN_OPERATOR,
+]);
 exports.default = BinaryExpressionNode;

package/cjs/helpers/kscript/nodes/expressions/CallExpression.d.ts

@@ -3,6 +3,7 @@ import Context from '../../Context';
 import Node from '../Node';
 export default class CallExpressionNode extends Node<CallExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     private spreadArgs;
 }

package/cjs/helpers/kscript/nodes/expressions/CallExpression.js

@@ -9,9 +9,19 @@ class CallExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'CallExpression');
     }
-    run() {
+    validate(validateChildren = false) {
         if (!this.context.isFunctionCallAllowed)
             throw new Error('Function calls are not allowed');
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.callee, this.context).validate(true);
+        for (const arg of this.node.arguments) {
+            (0, utils_1.construct)(arg, this.context).validate(true);
+        }
+    }
+    run() {
+        this.validate();
         const callee = (0, utils_1.construct)(this.node.callee, this.context).run();
         let thisArg = {};
         if (this.node.callee.type === 'MemberExpression') {

package/cjs/helpers/kscript/nodes/expressions/ChainExpression.d.ts

@@ -12,5 +12,6 @@ import Node from '../Node';
  */
 export default class ExpressionStatementNode extends Node<ChainExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ChainExpression.js

@@ -18,6 +18,7 @@ class ExpressionStatementNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'ChainExpression');
     }
+    validate() { }
     run() {
         return (0, utils_1.construct)(this.node.expression, this.context).run();
     }

package/cjs/helpers/kscript/nodes/expressions/ConditionalExpression.d.ts

@@ -10,5 +10,6 @@ import Node from '../Node';
  */
 export default class ConditionalExpressionNode extends Node<IfStatement | ConditionalExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ConditionalExpression.js

@@ -16,6 +16,16 @@ class ConditionalExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, ['ConditionalExpression', 'IfStatement']);
     }
+    validate(validateChildren) {
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.test, this.context).validate(true);
+        (0, utils_1.construct)(this.node.consequent, this.context).validate(true);
+        if (this.node.alternate !== null && this.node.alternate !== undefined) {
+            (0, utils_1.construct)(this.node.alternate, this.context).validate(true);
+        }
+    }
     run() {
         const test = (0, utils_1.construct)(this.node.test, this.context).run();
         if (test) {

package/cjs/helpers/kscript/nodes/expressions/ExpressionStatement.d.ts

@@ -3,5 +3,6 @@ import Context from '../../Context';
 import Node from '../Node';
 export default class ExpressionStatementNode extends Node<ExpressionStatement> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
 }

package/cjs/helpers/kscript/nodes/expressions/ExpressionStatement.js

@@ -9,9 +9,16 @@ class ExpressionStatementNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'ExpressionStatement');
     }
-    run() {
+    validate(validateChildren = false) {
         if (this.node.directive)
             throw new Error('Directives are not supported');
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.expression, this.context).validate(true);
+    }
+    run() {
+        this.validate();
         return (0, utils_1.construct)(this.node.expression, this.context).run();
     }
 }

package/cjs/helpers/kscript/nodes/expressions/LogicalExpression.d.ts

@@ -2,7 +2,9 @@ import { AnyNode, LogicalExpression } from 'acorn';
 import Context from '../../Context';
 import Node from '../Node';
 export default class BinaryExpressionNode extends Node<LogicalExpression> {
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
     /** Try and skip evaluating the right operand */
     private shortCircuit;

package/cjs/helpers/kscript/nodes/expressions/LogicalExpression.js

@@ -9,6 +9,16 @@ class BinaryExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'LogicalExpression');
     }
+    validate(validateChildren) {
+        if (!BinaryExpressionNode.SUPPORTED_OPERATORS.has(this.node.operator)) {
+            throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.left, this.context).validate(true);
+        (0, utils_1.construct)(this.node.right, this.context).validate(true);
+    }
     run() {
         const left = (0, utils_1.construct)(this.node.left, this.context).run();
         const shortCircuit = this.shortCircuit(left);
@@ -44,4 +54,5 @@ class BinaryExpressionNode extends Node_1.default {
         }
     }
 }
+BinaryExpressionNode.SUPPORTED_OPERATORS = new Set(['||', '&&', '??']);
 exports.default = BinaryExpressionNode;

package/cjs/helpers/kscript/nodes/expressions/MemberExpression.d.ts

@@ -22,6 +22,7 @@ import Node from '../Node';
  */
 export default class MemberExpressionNode extends Node<MemberExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren?: boolean): void;
     run(): unknown;
     /** Returns the name of the property being accessed.
      *

package/cjs/helpers/kscript/nodes/expressions/MemberExpression.js

@@ -28,6 +28,13 @@ class MemberExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'MemberExpression');
     }
+    validate(validateChildren = false) {
+        if (!validateChildren) {
+            return;
+        }
+        (0, utils_1.construct)(this.node.object, this.context).validate(true);
+        (0, utils_1.construct)(this.node.property, this.context).validate(true);
+    }
     run() {
         const object = (0, utils_1.construct)(this.node.object, this.context).run();
         if (object === null || object === undefined) {

package/cjs/helpers/kscript/nodes/expressions/ObjectExpression.d.ts

@@ -3,6 +3,7 @@ import type Context from '../../Context';
 import Node from '../Node';
 export default class ObjectExpressionNode extends Node<ObjectExpression> {
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
     private addProperty;
     private spreadProperty;

package/cjs/helpers/kscript/nodes/expressions/ObjectExpression.js

@@ -9,6 +9,35 @@ class ObjectExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'ObjectExpression');
     }
+    validate(validateChildren) {
+        for (const property of this.node.properties) {
+            // SpreadElements do not need to be validated - they only have a single argument
+            if (property.type === 'SpreadElement') {
+                continue;
+            }
+            if (property.kind !== 'init') {
+                // do not support getters or setters
+                throw new Error('Only init properties are supported');
+            }
+            if (!property.computed) {
+                // ensure that the key is valid
+                this.getStaticKey(property.key);
+            }
+        }
+        if (!validateChildren) {
+            return;
+        }
+        for (const property of this.node.properties) {
+            if (property.type === 'SpreadElement') {
+                (0, utils_1.construct)(property.argument, this.context).validate(true);
+                continue;
+            }
+            if (property.computed) {
+                (0, utils_1.construct)(property.key, this.context).validate(true);
+            }
+            (0, utils_1.construct)(property.value, this.context).validate(true);
+        }
+    }
     run() {
         const object = {};
         for (const property of this.node.properties) {

package/cjs/helpers/kscript/nodes/expressions/UnaryExpression.d.ts

@@ -6,7 +6,9 @@ import Node from '../Node';
  * e.g. `+1`, `-2`, `!true`, `typeof x`
  */
 export default class UnaryExpressionNode extends Node<UnaryExpression> {
+    private static readonly SUPPORTED_OPERATORS;
     constructor(node: AnyNode, context: Context);
+    validate(validateChildren: boolean): void;
     run(): unknown;
     private arithmetic;
 }

package/cjs/helpers/kscript/nodes/expressions/UnaryExpression.js

@@ -13,6 +13,14 @@ class UnaryExpressionNode extends Node_1.default {
     constructor(node, context) {
         super(node, context, 'UnaryExpression');
     }
+    validate(validateChildren) {
+        if (!UnaryExpressionNode.SUPPORTED_OPERATORS.has(this.node.operator)) {
+            throw new Error(`Unsupported operator: ${this.node.operator}`);
+        }
+        if (validateChildren) {
+            (0, utils_1.construct)(this.node.argument, this.context).validate(true);
+        }
+    }
     run() {
         const argument = (0, utils_1.construct)(this.node.argument, this.context).run();
         switch (this.node.operator) {
@@ -41,4 +49,5 @@ class UnaryExpressionNode extends Node_1.default {
         }
     }
 }
+UnaryExpressionNode.SUPPORTED_OPERATORS = new Set(['+', '-', '!', 'typeof']);
 exports.default = UnaryExpressionNode;

package/cjs/models/asset-storage/SyncIntegrations.d.ts

@@ -12,9 +12,9 @@ export interface AssetSyncDefinitionModel {
 export interface AssetSyncDefinitionOverrideModel extends AssetSyncDefinitionModel {
     _isOverridden: boolean;
 }
-export interface AssetSyncDefinitionsModel {
-    items: AssetSyncDefinitionModel[];
-    profileOverriddenItems?: AssetSyncDefinitionOverrideModel[];
+export interface AssetSyncDefinitionsModel<I extends AssetSyncDefinitionModel = AssetSyncDefinitionOverrideModel> {
+    items: I[];
+    profileOverriddenItems?: AssetSyncDefinitionModel[];
 }
 export interface AssetSyncIntegrationProviderModel {
     provider: string;

package/cjs/services/AssetStorageService.d.ts

@@ -1,4 +1,4 @@
-import { AssetItemModel, AssetItemWithObservationsModel, AssetSyncDefinitionsModel, AssetSyncIntegrationModel, AssetSyncIntegrationProviderModel, CreateAssetSyncIntegrationModel, IBaseService, IRocosSDKConfig, RocosError } from '../models';
+import { AssetItemModel, AssetItemWithObservationsModel, AssetSyncDefinitionModel, AssetSyncDefinitionsModel, AssetSyncIntegrationModel, AssetSyncIntegrationProviderModel, CreateAssetSyncIntegrationModel, IBaseService, IRocosSDKConfig, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 export declare class AssetStorageService extends BaseServiceAbstract implements IBaseService {
     constructor(config: IRocosSDKConfig);
@@ -92,7 +92,7 @@ export declare class AssetStorageService extends BaseServiceAbstract implements
      * @param definition
      * @param syncNow - Sync configured paths immediately
      */
-    setRobotSyncDefinitions(projectId: string, callsign: string, definition: AssetSyncDefinitionsModel, syncNow?: boolean): Promise<AssetSyncDefinitionsModel>;
+    setRobotSyncDefinitions(projectId: string, callsign: string, definition: AssetSyncDefinitionsModel<AssetSyncDefinitionModel>, syncNow?: boolean): Promise<AssetSyncDefinitionsModel>;
     /**
      * Get Robot Sync Definitions
      * @param projectId
@@ -105,7 +105,7 @@ export declare class AssetStorageService extends BaseServiceAbstract implements
      * @param profileId
      * @param definition
      */
-    setProfileSyncDefinitions(projectId: string, profileId: string, definition: AssetSyncDefinitionsModel): Promise<AssetSyncDefinitionsModel>;
+    setProfileSyncDefinitions(projectId: string, profileId: string, definition: Omit<AssetSyncDefinitionsModel<AssetSyncDefinitionModel>, 'profileOverriddenItems'>): Promise<AssetSyncDefinitionsModel>;
     /**
      * Get Profile Sync Definitions
      * @param projectId

package/cjs/services/MapService.d.ts

@@ -22,9 +22,10 @@ export declare class MapService extends BaseServiceAbstract implements IBaseServ
      *
      * @param projectId Project ID
      * @param callsign Robot callsign
+     * @param includeSystem Include system maps
      * @returns All maps in the cloud
      */
-    list(projectId: string, callsign: string): Promise<Map[]>;
+    list(projectId: string, callsign: string, includeSystem: boolean): Promise<Map[]>;
     /** List maps to be deployed to a callsign
      *
      * @param projectId