@lumikmz/kmz 0.2.0

package/src/plan/plan.test.ts

@@ -0,0 +1,96 @@
+import { describe, expect, it } from "vitest";
+import { degrees, meters, metersPerSecond } from "../types/branded.js";
+import { DroneEnum, PayloadEnum } from "../types/drone-payload.js";
+import type { Mapping2dTemplate, WaypointTemplate } from "../types/template.js";
+import { plan } from "./index.js";
+
+const missionConfig = {
+  flyToWaylineMode: "safely" as const,
+  finishAction: "goHome" as const,
+  exitOnRCLost: "executeLostAction" as const,
+  executeRCLostAction: "goBack" as const,
+  takeOffSecurityHeight: meters(20),
+  globalTransitionalSpeed: metersPerSecond(10),
+  globalRTHHeight: meters(100),
+  droneInfo: { ...DroneEnum.M3TD },
+  payloadInfo: [{ ...PayloadEnum.M3TDCamera }],
+};
+
+describe("plan", () => {
+  it("compiles a waypoint template into a single-folder wayline", () => {
+    const template: WaypointTemplate = {
+      missionConfig,
+      Folder: {
+        templateType: "waypoint",
+        templateId: 0,
+        waylineCoordinateSysParam: { coordinateMode: "WGS84", heightMode: "relativeToStartPoint" },
+        autoFlightSpeed: metersPerSecond(10),
+        globalWaypointTurnMode: "toPointAndStopWithDiscontinuityCurvature",
+        gimbalPitchMode: "manual",
+        globalHeight: meters(50),
+        globalWaypointHeadingParam: {
+          waypointHeadingMode: "followWayline",
+          waypointHeadingPathMode: "followBadArc",
+        },
+        Placemark: [
+          {
+            Point: { coordinates: { lng: 113.938, lat: 22.5397 } },
+            index: 0,
+            useGlobalHeight: true,
+            useGlobalSpeed: true,
+            useGlobalHeadingParam: true,
+            useGlobalTurnParam: true,
+          },
+          {
+            Point: { coordinates: { lng: 113.939, lat: 22.5407 } },
+            index: 1,
+            useGlobalHeight: true,
+            useGlobalSpeed: true,
+            useGlobalHeadingParam: true,
+            useGlobalTurnParam: true,
+          },
+        ],
+      },
+    };
+
+    const waylines = plan(template);
+    expect(waylines.Folder).toHaveLength(1);
+    expect(waylines.Folder[0]!.Placemark).toHaveLength(2);
+    expect(waylines.Folder[0]!.executeHeightMode).toBe("relativeToStartPoint");
+    expect(waylines.Folder[0]!.Placemark[0]!.executeHeight).toBe(50);
+    expect(waylines.missionConfig).toBe(template.missionConfig);
+  });
+
+  it("compiles a mapping2d template into a serpentine scan", () => {
+    const template: Mapping2dTemplate = {
+      missionConfig,
+      Folder: {
+        templateType: "mapping2d",
+        templateId: 1,
+        waylineCoordinateSysParam: { coordinateMode: "WGS84", heightMode: "relativeToStartPoint" },
+        autoFlightSpeed: metersPerSecond(10),
+        elevationOptimizeEnable: false,
+        shootType: "distance",
+        direction: degrees(0),
+        margin: 0,
+        overlap: { orthoCameraOverlapH: 80, orthoCameraOverlapW: 70 },
+        ellipsoidHeight: meters(150),
+        height: meters(100),
+        Placemark: {
+          Polygon: {
+            outerBoundaryIs: {
+              LinearRing: {
+                coordinates:
+                  "113.938,22.5397,0 113.940,22.5397,0 113.940,22.5407,0 113.938,22.5407,0 113.938,22.5397,0",
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const waylines = plan(template);
+    expect(waylines.Folder).toHaveLength(1);
+    expect(waylines.Folder[0]!.Placemark.length).toBeGreaterThan(0);
+  });
+});

package/src/types/action.ts

@@ -0,0 +1,253 @@
+import type { Degrees } from "./branded.js";
+import type {
+  ActionGroupMode,
+  ActionTriggerType,
+  AircraftPathMode,
+  GimbalHeadingYawBase,
+  GimbalRotateMode,
+  LensType,
+  OrientedPhotoMode,
+  PanoShotSubMode,
+  RecordPointCloudOperate,
+} from "./enums.js";
+
+/**
+ * `wpml:actionGroup` — see `docs/kmz/common-element.html` §actionGroup.
+ *
+ * - `actionGroupId` is unique within the entire KMZ (monotonically from 0).
+ * - `actionId` is scoped within its group.
+ */
+export interface ActionGroup {
+  actionGroupId: number;
+  actionGroupStartIndex: number;
+  actionGroupEndIndex: number;
+  actionGroupMode: ActionGroupMode;
+  actionTrigger: ActionTrigger;
+  action: Action[];
+}
+
+export interface ActionTrigger {
+  actionTriggerType: ActionTriggerType;
+  /** Seconds for `multipleTiming`, meters for `multipleDistance`. */
+  actionTriggerParam?: number;
+}
+
+/** Discriminated by `actionActuatorFunc`. */
+export type Action =
+  | TakePhotoAction
+  | StartRecordAction
+  | StopRecordAction
+  | FocusAction
+  | ZoomAction
+  | CustomDirNameAction
+  | GimbalRotateAction
+  | RotateYawAction
+  | HoverAction
+  | GimbalEvenlyRotateAction
+  | AccurateShootAction
+  | OrientedShootAction
+  | PanoShotAction
+  | RecordPointCloudAction
+  | MegaphoneAction
+  | SearchlightAction;
+
+interface ActionBase<F extends string, P> {
+  actionId: number;
+  actionActuatorFunc: F;
+  actionActuatorFuncParam: P;
+}
+
+// ─── Action params (one type per actionActuatorFunc) ─────────────────────────
+
+export interface TakePhotoParam {
+  payloadPositionIndex: number;
+  fileSuffix?: string;
+  payloadLensIndex?: LensType[];
+  useGlobalPayloadLensIndex: boolean;
+}
+export type TakePhotoAction = ActionBase<"takePhoto", TakePhotoParam>;
+
+export interface StartRecordParam {
+  payloadPositionIndex: number;
+  fileSuffix?: string;
+  payloadLensIndex?: LensType[];
+  useGlobalPayloadLensIndex: boolean;
+}
+export type StartRecordAction = ActionBase<"startRecord", StartRecordParam>;
+
+export interface StopRecordParam {
+  payloadPositionIndex: number;
+  payloadLensIndex?: LensType[];
+}
+export type StopRecordAction = ActionBase<"stopRecord", StopRecordParam>;
+
+export interface FocusParam {
+  payloadPositionIndex: number;
+  isPointFocus: boolean;
+  focusX: number;
+  focusY: number;
+  /** Required iff `isPointFocus === false`. */
+  focusRegionWidth?: number;
+  /** Required iff `isPointFocus === false`. */
+  focusRegionHeight?: number;
+  /** Required on M3E/M3T/M3M, M3D/M3TD, M4D/M4TD, M4E/M4T. */
+  isInfiniteFocus?: boolean;
+}
+export type FocusAction = ActionBase<"focus", FocusParam>;
+
+export interface ZoomParam {
+  payloadPositionIndex: number;
+  /** mm, > 0. */
+  focalLength: number;
+}
+export type ZoomAction = ActionBase<"zoom", ZoomParam>;
+
+export interface CustomDirNameParam {
+  payloadPositionIndex: number;
+  directoryName: string;
+}
+export type CustomDirNameAction = ActionBase<"customDirName", CustomDirNameParam>;
+
+export interface GimbalRotateParam {
+  payloadPositionIndex: number;
+  gimbalHeadingYawBase: GimbalHeadingYawBase;
+  gimbalRotateMode: GimbalRotateMode;
+  gimbalPitchRotateEnable: boolean;
+  gimbalPitchRotateAngle: Degrees;
+  gimbalRollRotateEnable: boolean;
+  gimbalRollRotateAngle: Degrees;
+  gimbalYawRotateEnable: boolean;
+  gimbalYawRotateAngle: Degrees;
+  gimbalRotateTimeEnable: boolean;
+  /** seconds */
+  gimbalRotateTime: number;
+}
+export type GimbalRotateAction = ActionBase<"gimbalRotate", GimbalRotateParam>;
+
+export interface RotateYawParam {
+  /** `[-180, 180]`, 0=N, 90=E, -90=W, ±180=S. */
+  aircraftHeading: Degrees;
+  /** Required on M300/M350. */
+  aircraftPathMode?: AircraftPathMode;
+}
+export type RotateYawAction = ActionBase<"rotateYaw", RotateYawParam>;
+
+export interface HoverParam {
+  /** seconds, > 0. */
+  hoverTime: number;
+}
+export type HoverAction = ActionBase<"hover", HoverParam>;
+
+export interface GimbalEvenlyRotateParam {
+  payloadPositionIndex: number;
+  gimbalPitchRotateAngle: Degrees;
+}
+/** Must be paired with `actionTriggerType === "betweenAdjacentPoints"`. */
+export type GimbalEvenlyRotateAction = ActionBase<"gimbalEvenlyRotate", GimbalEvenlyRotateParam>;
+
+/** Deprecated for M30/M30T after firmware V06.01.10.02. Prefer `orientedShoot`. */
+export interface AccurateShootParam {
+  gimbalPitchRotateAngle: Degrees;
+  gimbalYawRotateAngle: Degrees;
+  focusX: number;
+  focusY: number;
+  focusRegionWidth: number;
+  focusRegionHeight: number;
+  focalLength: number;
+  aircraftHeading: Degrees;
+  accurateFrameValid: boolean;
+  payloadPositionIndex: number;
+  payloadLensIndex: LensType[];
+  useGlobalPayloadLensIndex: boolean;
+  targetAngle: Degrees;
+  imageWidth: number;
+  imageHeight: number;
+  AFPos: number;
+  gimbalPort: number;
+  accurateCameraType: number;
+  accurateFilePath: string;
+  accurateFileMD5: string;
+  accurateFileSize: number;
+  accurateFileSuffix: string;
+  accurateCameraApertue?: number;
+  accurateCameraLuminance?: number;
+  accurateCameraShutterTime?: number;
+  accurateCameraISO?: number;
+}
+export type AccurateShootAction = ActionBase<"accurateShoot", AccurateShootParam>;
+
+export interface OrientedShootParam {
+  gimbalPitchRotateAngle: Degrees;
+  gimbalYawRotateAngle: Degrees;
+  focusX: number;
+  focusY: number;
+  focusRegionWidth: number;
+  focusRegionHeight: number;
+  focalLength: number;
+  aircraftHeading: Degrees;
+  accurateFrameValid: boolean;
+  payloadPositionIndex: number;
+  payloadLensIndex: LensType[];
+  useGlobalPayloadLensIndex: boolean;
+  targetAngle: Degrees;
+  actionUUID: string;
+  imageWidth: number;
+  imageHeight: number;
+  AFPos: number;
+  gimbalPort: number;
+  orientedCameraType: number;
+  orientedFilePath: string;
+  orientedFileMD5: string;
+  orientedFileSize: number;
+  orientedFileSuffix: string;
+  orientedCameraApertue: number;
+  orientedCameraLuminance: number;
+  orientedCameraShutterTime: number;
+  orientedCameraISO: number;
+  orientedPhotoMode: OrientedPhotoMode;
+}
+export type OrientedShootAction = ActionBase<"orientedShoot", OrientedShootParam>;
+
+export interface PanoShotParam {
+  payloadPositionIndex?: number;
+  payloadLensIndex?: LensType[];
+  useGlobalPayloadLensIndex?: boolean;
+  panoShotSubMode: PanoShotSubMode;
+}
+export type PanoShotAction = ActionBase<"panoShot", PanoShotParam>;
+
+export interface RecordPointCloudParam {
+  payloadPositionIndex: number;
+  recordPointCloudOperate: RecordPointCloudOperate;
+}
+export type RecordPointCloudAction = ActionBase<"recordPointCloud", RecordPointCloudParam>;
+
+/** M4D/M4TD only. */
+export interface MegaphoneParam {
+  payloadPositionIndex: number;
+  actionUUID: string;
+  /** 0 = start, 1 = stop. */
+  megaphoneOperateType: 0 | 1;
+  /** 0–100. */
+  megaphoneOperateVolume: number;
+  megaphoneOperateLoop: boolean;
+  /** Path inside KMZ, e.g. `/wpmz/res/audio/<hash>.opus`. */
+  megaphoneOperateFilePath: string;
+  megaphoneFileName: string;
+  megaphoneFileOriginalName: string;
+  megaphoneFileMd5: string;
+  /** 1=8000, 2=16000, 3=24000, 4=32000, 5=48000, 6=64000 (only 4 supported today). */
+  megaphoneFileBitrate: 1 | 2 | 3 | 4 | 5 | 6;
+}
+export type MegaphoneAction = ActionBase<"megaphone", MegaphoneParam>;
+
+/** M4D/M4TD only. */
+export interface SearchlightParam {
+  payloadPositionIndex: number;
+  actionUUID?: string;
+  /** 0 = off, 1 = illuminate, 2 = flash. */
+  searchlightOperateType: 0 | 1 | 2;
+  /** 0–100. */
+  searchlightBrightness: number;
+}
+export type SearchlightAction = ActionBase<"searchlight", SearchlightParam>;

package/src/types/branded.ts

@@ -0,0 +1,20 @@
+type Brand<T, B> = T & { readonly __brand: B };
+
+export type Meters = Brand<number, "Meters">;
+export type MetersPerSecond = Brand<number, "MetersPerSecond">;
+export type Degrees = Brand<number, "Degrees">;
+
+export const meters = (n: number) => n as Meters;
+export const metersPerSecond = (n: number) => n as MetersPerSecond;
+export const degrees = (n: number) => n as Degrees;
+
+export interface LngLat {
+  readonly lng: number;
+  readonly lat: number;
+}
+
+export interface LngLatHeight {
+  readonly lng: number;
+  readonly lat: number;
+  readonly height: Meters;
+}

package/src/types/drone-payload.ts

@@ -0,0 +1,59 @@
+// Drone & payload enum tables from docs/kmz/product-support.html.
+// `droneEnumValue` (type) + `droneSubEnumValue` (sub_type) together identify the model.
+
+export interface DroneInfo {
+  droneEnumValue: number;
+  droneSubEnumValue?: number;
+}
+
+export interface PayloadInfo {
+  payloadEnumValue: number;
+  payloadPositionIndex: number;
+}
+
+/** Aircraft `{ droneEnumValue, droneSubEnumValue }` tuples. */
+export const DroneEnum = {
+  M400: { droneEnumValue: 103, droneSubEnumValue: 0 },
+  M350RTK: { droneEnumValue: 89, droneSubEnumValue: 0 },
+  M300RTK: { droneEnumValue: 60, droneSubEnumValue: 0 },
+  M30: { droneEnumValue: 67, droneSubEnumValue: 0 },
+  M30T: { droneEnumValue: 67, droneSubEnumValue: 1 },
+  M3E: { droneEnumValue: 77, droneSubEnumValue: 0 },
+  M3T: { droneEnumValue: 77, droneSubEnumValue: 1 },
+  M3TA: { droneEnumValue: 77, droneSubEnumValue: 3 },
+  M3D: { droneEnumValue: 91, droneSubEnumValue: 0 },
+  M3TD: { droneEnumValue: 91, droneSubEnumValue: 1 },
+  M4D: { droneEnumValue: 100, droneSubEnumValue: 0 },
+  M4TD: { droneEnumValue: 100, droneSubEnumValue: 1 },
+  M4E: { droneEnumValue: 99, droneSubEnumValue: 0 },
+  M4T: { droneEnumValue: 99, droneSubEnumValue: 1 },
+} as const satisfies Record<string, DroneInfo>;
+
+/** Payload `{ payloadEnumValue, payloadPositionIndex }` tuples for common cameras. */
+export const PayloadEnum = {
+  // Main gimbal cameras
+  M30Camera: { payloadEnumValue: 52, payloadPositionIndex: 0 },
+  M30TCamera: { payloadEnumValue: 53, payloadPositionIndex: 0 },
+  M3ECamera: { payloadEnumValue: 66, payloadPositionIndex: 0 },
+  M3TCamera: { payloadEnumValue: 67, payloadPositionIndex: 0 },
+  M3TACamera: { payloadEnumValue: 129, payloadPositionIndex: 0 },
+  M3DCamera: { payloadEnumValue: 80, payloadPositionIndex: 0 },
+  M3TDCamera: { payloadEnumValue: 81, payloadPositionIndex: 0 },
+  M4DCamera: { payloadEnumValue: 98, payloadPositionIndex: 0 },
+  M4TDCamera: { payloadEnumValue: 99, payloadPositionIndex: 0 },
+  M4ECamera: { payloadEnumValue: 88, payloadPositionIndex: 0 },
+  M4TCamera: { payloadEnumValue: 89, payloadPositionIndex: 0 },
+  // Zenmuse mounts: 0=front-left/main, 1=front-right, 2=top (M300 RTK), 0=main for others
+  ZenmuseZ30: { payloadEnumValue: 20, payloadPositionIndex: 0 },
+  ZenmuseXT2: { payloadEnumValue: 26, payloadPositionIndex: 0 },
+  ZenmuseXTS: { payloadEnumValue: 41, payloadPositionIndex: 0 },
+  ZenmuseH20: { payloadEnumValue: 42, payloadPositionIndex: 0 },
+  ZenmuseH20T: { payloadEnumValue: 43, payloadPositionIndex: 0 },
+  ZenmuseH20N: { payloadEnumValue: 61, payloadPositionIndex: 0 },
+  ZenmuseH30: { payloadEnumValue: 82, payloadPositionIndex: 0 },
+  ZenmuseH30T: { payloadEnumValue: 83, payloadPositionIndex: 0 },
+  // FPV / aux
+  FPVMatriceSeries: { payloadEnumValue: 39, payloadPositionIndex: 7 },
+  AuxiliaryM3xM4x: { payloadEnumValue: 176, payloadPositionIndex: 0 },
+  DockCamera: { payloadEnumValue: 165, payloadPositionIndex: 7 },
+} as const satisfies Record<string, PayloadInfo>;

package/src/types/enums.ts

@@ -0,0 +1,97 @@
+// Enum string literals mirror DJI WPML spec verbatim, including typos (`visable`, `followBadArc`).
+
+export type FlyToWaylineMode = "safely" | "pointToPoint";
+
+export type FinishAction = "goHome" | "noAction" | "autoLand" | "gotoFirstWaypoint";
+
+export type ExitOnRCLost = "goContinue" | "executeLostAction";
+
+export type ExecuteRCLostAction = "goBack" | "landing" | "hover";
+
+export type TemplateType = "waypoint" | "mapping2d" | "mapping3d" | "mappingStrip";
+
+export type CoordinateMode = "WGS84";
+
+/** Used in template.kml `waylineCoordinateSysParam.heightMode`. */
+export type TemplateHeightMode =
+  | "EGM96"
+  | "relativeToStartPoint"
+  | "aboveGroundLevel"
+  | "realTimeFollowSurface";
+
+/** Used in waylines.wpml `Folder.executeHeightMode`. */
+export type ExecuteHeightMode = "WGS84" | "relativeToStartPoint" | "realTimeFollowSurface";
+
+export type PositioningType = "GPS" | "RTKBaseStation" | "QianXun" | "Custom";
+
+export type WaypointTurnMode =
+  | "coordinateTurn"
+  | "toPointAndStopWithDiscontinuityCurvature"
+  | "toPointAndStopWithContinuityCurvature"
+  | "toPointAndPassWithContinuityCurvature";
+
+export type WaypointHeadingMode =
+  | "followWayline"
+  | "manually"
+  | "fixed"
+  | "smoothTransition"
+  | "towardPOI";
+
+/** Spec typo preserved: `followBadArc` (intended "shortest path / smaller arc"). */
+export type WaypointHeadingPathMode = "clockwise" | "counterClockwise" | "followBadArc";
+
+/** Template waypoint folder allows manual + per-point; mapping templates allow manual + fixed. */
+export type GimbalPitchMode = "manual" | "usePointSetting" | "fixed";
+
+export type ShootType = "time" | "distance";
+
+export type MappingHeadingMode = "fixed" | "followWayline";
+
+/** Spec typo preserved: `visable`. */
+export type LensType = "wide" | "zoom" | "ir" | "narrow_band" | "visable";
+
+export type FocusMode = "firstPoint" | "custom";
+
+export type MeteringMode = "average" | "spot";
+
+export type LidarReturnMode = "singleReturnStrongest" | "dualReturn" | "tripleReturn";
+
+export type LidarScanningMode = "repetitive" | "nonRepetitive";
+
+export type ActionGroupMode = "sequence";
+
+export type ActionTriggerType =
+  | "reachPoint"
+  | "betweenAdjacentPoints"
+  | "multipleTiming"
+  | "multipleDistance";
+
+export type ActionActuatorFunc =
+  | "takePhoto"
+  | "startRecord"
+  | "stopRecord"
+  | "focus"
+  | "zoom"
+  | "customDirName"
+  | "gimbalRotate"
+  | "rotateYaw"
+  | "hover"
+  | "gimbalEvenlyRotate"
+  | "accurateShoot"
+  | "orientedShoot"
+  | "panoShot"
+  | "recordPointCloud"
+  | "megaphone"
+  | "searchlight";
+
+export type GimbalHeadingYawBase = "north";
+
+export type GimbalRotateMode = "absoluteAngle";
+
+export type AircraftPathMode = "clockwise" | "counterClockwise";
+
+export type RecordPointCloudOperate = "startRecord" | "pauseRecord" | "resumeRecord" | "stopRecord";
+
+export type PanoShotSubMode = "panoShot_360";
+
+export type OrientedPhotoMode = "normalPhoto" | "lowLightSmartShooting";

package/src/types/errors.ts

@@ -0,0 +1,19 @@
+export class KmzError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "KmzError";
+  }
+}
+
+export class PlannerError extends KmzError {
+  constructor(message: string) {
+    super(message);
+    this.name = "PlannerError";
+  }
+}
+
+export interface Issue {
+  path: string;
+  message: string;
+  severity: "error" | "warning";
+}

package/src/types/index.ts

@@ -0,0 +1,10 @@
+export * from "./branded.js";
+export * from "./errors.js";
+export * from "./enums.js";
+export * from "./drone-payload.js";
+export * from "./mission-config.js";
+export * from "./waypoint-params.js";
+export * from "./action.js";
+export * from "./placemark.js";
+export * from "./template.js";
+export * from "./waylines.js";

package/src/types/mission-config.ts

@@ -0,0 +1,58 @@
+import type { LngLatHeight, Meters, MetersPerSecond } from "./branded.js";
+import type { DroneInfo, PayloadInfo } from "./drone-payload.js";
+import type {
+  ExecuteRCLostAction,
+  ExitOnRCLost,
+  FinishAction,
+  FlyToWaylineMode,
+  FocusMode,
+  LensType,
+  LidarReturnMode,
+  LidarScanningMode,
+  MeteringMode,
+} from "./enums.js";
+
+/**
+ * `wpml:missionConfig` — shared between template.kml and waylines.wpml.
+ * See `docs/kmz/common-element.html` §missionConfig.
+ */
+export interface MissionConfig {
+  flyToWaylineMode: FlyToWaylineMode;
+  finishAction: FinishAction;
+  exitOnRCLost: ExitOnRCLost;
+  /** Required iff `exitOnRCLost === "executeLostAction"`. */
+  executeRCLostAction?: ExecuteRCLostAction;
+  takeOffSecurityHeight: Meters;
+  /** lat/lng with WGS84 ellipsoid height. Optional; only used for planning. */
+  takeOffRefPoint?: LngLatHeight;
+  /** AGL altitude of `takeOffRefPoint`. Paired with the ellipsoid height inside `takeOffRefPoint.height`. */
+  takeOffRefPointAGLHeight?: Meters;
+  globalTransitionalSpeed: MetersPerSecond;
+  globalRTHHeight: Meters;
+  droneInfo: DroneInfo;
+  payloadInfo: PayloadInfo[];
+  /** Only M3D/M3TD, M4D/M4TD, M4E/M4T. */
+  autoRerouteInfo?: AutoRerouteInfo;
+}
+
+export interface AutoRerouteInfo {
+  missionAutoRerouteMode: boolean;
+  transitionalAutoRerouteMode: boolean;
+}
+
+/**
+ * `wpml:payloadParam` — per-payload imaging settings.
+ * Lives under template `Folder`.
+ */
+export interface PayloadParam {
+  payloadPositionIndex: number;
+  focusMode?: FocusMode;
+  meteringMode?: MeteringMode;
+  dewarpingEnable?: boolean;
+  returnMode?: LidarReturnMode;
+  samplingRate?: 60000 | 80000 | 120000 | 160000 | 180000 | 240000;
+  scanningMode?: LidarScanningMode;
+  modelColoringEnable?: boolean;
+  /** Comma-joined `LensType` tokens, e.g. `["wide","ir"]`. */
+  imageFormat: LensType[];
+}