@lumikmz/kmz 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Zhaoyang Yuan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,540 @@
+# @lumikmz/kmz
+
+Spec-aligned TypeScript types for DJI KMZ/WPML missions, plus the `plan()` algorithm that compiles high-level templates into executable waylines and a `validate()` checker. Pure JavaScript — no WASM, no Rust, no file I/O.
+
+```sh
+npm install @lumikmz/kmz
+```
+
+## Table of contents
+
+- [Design philosophy](#design-philosophy)
+- [Public API](#public-api)
+  - [`plan(template)`](#plantemplate--waylines)
+  - [`validate(doc)`](#validatedoc--issue)
+- [Type reference](#type-reference)
+  - [Document roots](#document-roots-template--waylines)
+  - [MissionConfig](#missionconfig)
+  - [Folder types per templateType](#folder-types-per-templatetype)
+  - [Placemark](#placemark)
+  - [WaypointHeadingParam / WaypointTurnParam](#waypointheadingparam--waypointturnparam)
+  - [ActionGroup, Action, ActionTrigger](#actiongroup-action-actiontrigger)
+  - [Branded primitives](#branded-primitives)
+  - [Enums](#enums)
+  - [Drone & payload constants](#drone--payload-constants)
+- [How `plan()` dispatches](#how-plan-dispatches)
+
+## Design philosophy
+
+The type definitions are a **literal 1:1 mirror of the DJI WPML XML spec**, minus the `wpml:` prefix and with primitive values typed (numbers stay numbers, booleans stay booleans, `LngLat` is an object, not a `"lng,lat"` string). When the spec says `<wpml:Folder><wpml:Placemark><Point><coordinates>`, the TypeScript reads `Folder.Placemark.Point.coordinates`. When the spec spells something `visable` or `followBadArc`, the type literal does too — those misspellings are required by the DJI runtime.
+
+You can author a `Template` by reading [`docs/kmz/template-kml.html`](../../docs/kmz/template-kml.html) and writing the object directly. No factory functions are needed (and none are provided).
+
+## Public API
+
+### `plan(template) → Waylines`
+
+Compile a `Template` into the executable `Waylines` shape that DJI's flight controller expects. Pure computation — no I/O, no side effects.
+
+Dispatch is by `template.Folder.templateType`:
+
+| templateType    | Algorithm                                                                          |
+| --------------- | ---------------------------------------------------------------------------------- |
+| `waypoint`      | One Folder. Each template Placemark → one wayline Placemark, resolving `useGlobalXxx` flags against folder defaults. |
+| `mapping2d`     | One Folder. Boustrophedon (serpentine) scan over the Polygon at `folder.height`, line spacing computed from `overlap.orthoCameraOverlapW`. Per-segment `takePhoto` between adjacent points. |
+| `mapping3d`     | **Five Folders** — one nadir ortho pass + four oblique passes (front/back/left/right) at `inclinedGimbalPitch`. Photos timed via `multipleTiming` trigger. |
+| `mappingStrip`  | One Folder. LineString vertices become waypoints; if `stripUseTemplateAltitude` is true, per-vertex altitude is read from the LineString triples, otherwise folder `height` is used. |
+
+```ts
+import { plan } from "@lumikmz/kmz";
+
+const waylines = plan(template);
+// waylines.Folder is WaylinesFolder[] — length depends on templateType
+```
+
+### `validate(doc) → Issue[]`
+
+Run semantic checks against a `Template` or `Waylines`. Returns a list of `Issue`s; an empty array means valid. Non-throwing — callers decide how to react.
+
+```ts
+import { validate } from "@lumikmz/kmz";
+
+const issues = validate(template);
+const errors = issues.filter((i) => i.severity === "error");
+if (errors.length > 0) {
+  // refuse to ship
+}
+```
+
+Checks performed:
+
+- `missionConfig`: `executeRCLostAction` required when `exitOnRCLost === "executeLostAction"`; speed ranges; `payloadInfo` non-empty (warning).
+- Template: `templateId` ∈ `[0, 65535]`, `autoFlightSpeed` ∈ `[1, 15]`, waypoint Folder has ≥1 Placemark, mapping Folders have ≥3 polygon vertices, mappingStrip ≥2 LineString vertices.
+- Waylines: per-Placemark `index` monotonicity, per-Folder Placemark count ≥1, `waypointSpeed` ranges.
+
+```ts
+interface Issue {
+  path: string;          // dot-path to the offending field, e.g. "Folder.Placemark[2].waypointSpeed"
+  message: string;
+  severity: "error" | "warning";
+}
+```
+
+## Type reference
+
+### Document roots: `Template` & `Waylines`
+
+```ts
+type Template =
+  | WaypointTemplate
+  | Mapping2dTemplate
+  | Mapping3dTemplate
+  | MappingStripTemplate;
+
+interface TemplateDocumentBase {
+  author?: string;
+  createTime?: number;      // Unix ms
+  updateTime?: number;      // Unix ms
+  missionConfig: MissionConfig;
+  // Folder is added per variant
+}
+
+interface Waylines {
+  missionConfig: MissionConfig;
+  Folder: WaylinesFolder[]; // 1..* — mapping3d expands to 5
+}
+
+interface WaylinesFolder {
+  templateId: number;
+  waylineId: number;
+  executeHeightMode: ExecuteHeightMode;
+  autoFlightSpeed: MetersPerSecond;
+  startActionGroup?: ActionGroup;
+  Placemark: WaylinesPlacemark[];
+}
+```
+
+### `MissionConfig`
+
+Lives at the top level of both `template.kml` and `waylines.wpml`.
+
+```ts
+interface MissionConfig {
+  flyToWaylineMode: "safely" | "pointToPoint";
+  finishAction: "goHome" | "noAction" | "autoLand" | "gotoFirstWaypoint";
+  exitOnRCLost: "goContinue" | "executeLostAction";
+  executeRCLostAction?: "goBack" | "landing" | "hover";  // required iff exitOnRCLost === "executeLostAction"
+  takeOffSecurityHeight: Meters;
+  takeOffRefPoint?: LngLatHeight;
+  takeOffRefPointAGLHeight?: Meters;
+  globalTransitionalSpeed: MetersPerSecond;              // [1, 15]
+  globalRTHHeight: Meters;                               // [2, 1500]
+  droneInfo: DroneInfo;
+  payloadInfo: PayloadInfo[];
+  autoRerouteInfo?: AutoRerouteInfo;                     // M3D/M3TD, M4D/M4TD, M4E/M4T only
+}
+
+interface DroneInfo {
+  droneEnumValue: number;
+  droneSubEnumValue?: number;
+}
+
+interface PayloadInfo {
+  payloadEnumValue: number;
+  payloadPositionIndex: number;
+}
+
+interface AutoRerouteInfo {
+  missionAutoRerouteMode: boolean;
+  transitionalAutoRerouteMode: boolean;
+}
+```
+
+### Folder types per `templateType`
+
+Each Folder variant shares a base (`templateId`, `autoFlightSpeed`, `waylineCoordinateSysParam`, `payloadParam?`, `Placemark`) plus type-specific fields.
+
+#### `WaypointFolder` (`templateType: "waypoint"`)
+
+```ts
+interface WaypointFolder {
+  templateType: "waypoint";
+  templateId: number;
+  waylineCoordinateSysParam: WaylineCoordinateSysParam;
+  autoFlightSpeed: MetersPerSecond;
+  payloadParam?: PayloadParam;
+
+  globalWaypointTurnMode: WaypointTurnMode;
+  globalUseStraightLine?: boolean;        // required iff turnMode ∈ {ContinuityCurvature variants}
+  gimbalPitchMode: "manual" | "usePointSetting";
+  globalHeight: Meters;                   // relative to takeoff point
+  globalWaypointHeadingParam: WaypointHeadingParam;
+
+  Placemark: TemplateWaypointPlacemark[];
+}
+```
+
+#### `Mapping2dFolder` (`templateType: "mapping2d"`)
+
+```ts
+interface Mapping2dFolder {
+  templateType: "mapping2d";
+  templateId: number;
+  waylineCoordinateSysParam: WaylineCoordinateSysParam;
+  autoFlightSpeed: MetersPerSecond;
+  payloadParam?: PayloadParam;
+
+  caliFlightEnable?: boolean;             // M300/M350 only
+  elevationOptimizeEnable: boolean;
+  smartObliqueEnable?: boolean;           // turns "ortho" into "smart oblique"
+  smartObliqueGimbalPitch?: Degrees;
+
+  shootType: "time" | "distance";
+  direction: Degrees;                     // [0, 360]
+  margin: number;
+  overlap: Overlap;
+  ellipsoidHeight: Meters;
+  height: Meters;
+
+  facadeWaylineEnable?: boolean;          // M3E/M3T/M3M only
+  mappingHeadingParam?: MappingHeadingParam;
+  gimbalPitchMode?: "manual" | "fixed";
+  gimbalPitchAngle?: Degrees;             // required iff gimbalPitchMode === "fixed"
+  quickOrthoMappingEnable?: boolean;      // M4E only
+  quickOrthoMappingPitch?: Degrees;
+
+  Placemark: TemplatePolygonPlacemark;
+}
+```
+
+#### `Mapping3dFolder` (`templateType: "mapping3d"`)
+
+```ts
+interface Mapping3dFolder {
+  templateType: "mapping3d";
+  templateId: number;
+  waylineCoordinateSysParam: WaylineCoordinateSysParam;
+  autoFlightSpeed: MetersPerSecond;
+  payloadParam?: PayloadParam;
+
+  caliFlightEnable?: boolean;
+  inclinedGimbalPitch: Degrees;           // pitch for the 4 oblique passes
+  inclinedFlightSpeed: MetersPerSecond;   // [1, 15]
+  shootType: "time" | "distance";
+  direction: Degrees;
+  margin: number;
+  overlap: Overlap;
+  ellipsoidHeight: Meters;
+  height: Meters;
+
+  Placemark: TemplatePolygonPlacemark;
+}
+```
+
+#### `MappingStripFolder` (`templateType: "mappingStrip"`)
+
+```ts
+interface MappingStripFolder {
+  templateType: "mappingStrip";
+  templateId: number;
+  waylineCoordinateSysParam: WaylineCoordinateSysParam;
+  autoFlightSpeed: MetersPerSecond;
+  payloadParam?: PayloadParam;
+
+  caliFlightEnable: boolean;
+  shootType: "time" | "distance";
+  direction: Degrees;
+  margin: number;                         // float (vs integer in mapping2d/3d)
+  singleLineEnable: boolean;
+  cuttingDistance: number;
+  boundaryOptimEnable: boolean;
+  leftExtend: number;
+  rightExtend: number;
+  includeCenterEnable: boolean;
+  overlap: Overlap;
+  ellipsoidHeight: Meters;
+  height: Meters;
+  stripUseTemplateAltitude: boolean;      // when true, alt is read from LineString triples
+
+  Placemark: TemplateLineStringPlacemark;
+}
+```
+
+### Placemark
+
+Two Placemark shapes — one for `template.kml`, one for `waylines.wpml`.
+
+#### Template `Placemark`
+
+```ts
+interface TemplateWaypointPlacemark {
+  Point: { coordinates: LngLat };          // KML order: lng,lat
+  index: number;
+
+  useGlobalHeight: boolean;
+  ellipsoidHeight?: Meters;                // required iff useGlobalHeight=false; WGS84
+  height?: Meters;                         // required iff useGlobalHeight=false
+
+  useGlobalSpeed: boolean;
+  waypointSpeed?: MetersPerSecond;         // required iff useGlobalSpeed=false; [1, 15]
+
+  useGlobalHeadingParam: boolean;
+  waypointHeadingParam?: WaypointHeadingParam;
+
+  useGlobalTurnParam: boolean;
+  waypointTurnParam?: WaypointTurnParam;
+
+  useStraightLine?: boolean;               // required for certain turn modes
+  gimbalPitchAngle?: Degrees;              // required iff folder gimbalPitchMode === "usePointSetting"
+  isRisky?: boolean;                       // M30/M30T, M3D/M3TD, M4D/M4TD, M4E/M4T
+
+  actionGroup?: ActionGroup[];
+}
+
+interface TemplatePolygonPlacemark {
+  Polygon: {
+    outerBoundaryIs: {
+      LinearRing: { coordinates: string }; // space-separated lng,lat,alt triples
+    };
+  };
+}
+
+interface TemplateLineStringPlacemark {
+  LineString: { coordinates: string };     // space-separated lng,lat,alt triples
+}
+```
+
+#### Waylines `Placemark`
+
+The `useGlobalXxx` switches are template-only — in `waylines.wpml` all params are inlined unconditionally.
+
+```ts
+interface WaylinesPlacemark {
+  Point: { coordinates: LngLat };
+  index: number;
+  executeHeight: Meters;                   // interpreted per Folder.executeHeightMode
+  waypointSpeed: MetersPerSecond;          // [1, 15]
+  waypointHeadingParam: WaypointHeadingParam;
+  waypointTurnParam: WaypointTurnParam;
+  useStraightLine?: boolean;
+  isRisky?: boolean;
+  actionGroup?: ActionGroup[];
+}
+```
+
+### `WaypointHeadingParam` / `WaypointTurnParam`
+
+```ts
+interface WaypointHeadingParam {
+  waypointHeadingMode: "followWayline" | "manually" | "fixed" | "smoothTransition" | "towardPOI";
+  waypointHeadingAngle?: Degrees;          // [-180, 180]; required iff mode === "smoothTransition"
+  waypointPoiPoint?: LngLatHeight;         // required iff mode === "towardPOI"; height should be 0
+  waypointHeadingPathMode: "clockwise" | "counterClockwise" | "followBadArc";  // spec typo preserved
+}
+
+interface WaypointTurnParam {
+  waypointTurnMode:
+    | "coordinateTurn"
+    | "toPointAndStopWithDiscontinuityCurvature"
+    | "toPointAndStopWithContinuityCurvature"
+    | "toPointAndPassWithContinuityCurvature";
+  waypointTurnDampingDist?: Meters;        // required for coordinateTurn or pass+useStraightLine
+}
+
+interface WaylineCoordinateSysParam {
+  coordinateMode: "WGS84";                 // only value currently
+  heightMode: "EGM96" | "relativeToStartPoint" | "aboveGroundLevel" | "realTimeFollowSurface";
+  positioningType?: "GPS" | "RTKBaseStation" | "QianXun" | "Custom";
+  globalShootHeight?: Meters;              // mapping templates
+  surfaceFollowModeEnable?: boolean;       // mapping templates
+  surfaceRelativeHeight?: Meters;          // required iff surfaceFollowModeEnable === true
+}
+
+interface MappingHeadingParam {
+  mappingHeadingMode: "fixed" | "followWayline";
+  mappingHeadingAngle?: Degrees;           // [0, 360]; required iff mode === "fixed"
+}
+
+interface Overlap {
+  orthoLidarOverlapH?: number;             // 0–100, M300/M350 LiDAR
+  orthoLidarOverlapW?: number;
+  orthoCameraOverlapH?: number;            // 0–100, visible light
+  orthoCameraOverlapW?: number;
+  inclinedLidarOverlapH?: number;
+  inclinedLidarOverlapW?: number;
+  inclinedCameraOverlapH?: number;
+  inclinedCameraOverlapW?: number;
+}
+```
+
+### ActionGroup, Action, ActionTrigger
+
+`actionGroupId` is unique across the **entire** KMZ (monotonically from 0). `actionId` is scoped within its `ActionGroup`.
+
+```ts
+interface ActionGroup {
+  actionGroupId: number;
+  actionGroupStartIndex: number;
+  actionGroupEndIndex: number;             // ≥ start; equal means single-waypoint group
+  actionGroupMode: "sequence";             // only value currently
+  actionTrigger: ActionTrigger;
+  action: Action[];                        // 1..*
+}
+
+interface ActionTrigger {
+  actionTriggerType: "reachPoint" | "betweenAdjacentPoints" | "multipleTiming" | "multipleDistance";
+  actionTriggerParam?: number;             // seconds for multipleTiming; meters for multipleDistance
+}
+
+type Action =
+  | TakePhotoAction
+  | StartRecordAction
+  | StopRecordAction
+  | FocusAction
+  | ZoomAction
+  | CustomDirNameAction
+  | GimbalRotateAction
+  | RotateYawAction
+  | HoverAction
+  | GimbalEvenlyRotateAction
+  | AccurateShootAction
+  | OrientedShootAction
+  | PanoShotAction
+  | RecordPointCloudAction
+  | MegaphoneAction
+  | SearchlightAction;
+```
+
+Every `Action` has the shape:
+
+```ts
+interface ActionBase<F extends string, P> {
+  actionId: number;
+  actionActuatorFunc: F;
+  actionActuatorFuncParam: P;              // shape depends on F
+}
+```
+
+The 16 param shapes match [`docs/kmz/common-element.html` §action](../../docs/kmz/common-element.html) — every field, every model gating, every spec typo. Example:
+
+```ts
+interface TakePhotoParam {
+  payloadPositionIndex: number;
+  fileSuffix?: string;
+  payloadLensIndex?: LensType[];           // ["wide", "ir", ...]
+  useGlobalPayloadLensIndex: boolean;
+}
+
+interface GimbalRotateParam {
+  payloadPositionIndex: number;
+  gimbalHeadingYawBase: "north";
+  gimbalRotateMode: "absoluteAngle";
+  gimbalPitchRotateEnable: boolean;
+  gimbalPitchRotateAngle: Degrees;
+  gimbalRollRotateEnable: boolean;
+  gimbalRollRotateAngle: Degrees;
+  gimbalYawRotateEnable: boolean;
+  gimbalYawRotateAngle: Degrees;
+  gimbalRotateTimeEnable: boolean;
+  gimbalRotateTime: number;                // seconds
+}
+
+interface HoverParam {
+  hoverTime: number;                       // seconds, > 0
+}
+```
+
+For the full list — including `accurateShoot` (deprecated, prefer `orientedShoot`), `megaphone`, `searchlight`, `panoShot`, `recordPointCloud`, etc. — see [`src/types/action.ts`](src/types/action.ts) or [`docs/kmz-types-spec.md` §9](../../docs/kmz-types-spec.md).
+
+### Branded primitives
+
+Nominal types to prevent unit mix-ups. They are plain numbers at runtime.
+
+```ts
+type Meters          = number & { readonly __brand: "Meters" };
+type MetersPerSecond = number & { readonly __brand: "MetersPerSecond" };
+type Degrees         = number & { readonly __brand: "Degrees" };
+
+// Constructors (no-op at runtime)
+const meters          = (n: number): Meters          => n as Meters;
+const metersPerSecond = (n: number): MetersPerSecond => n as MetersPerSecond;
+const degrees         = (n: number): Degrees         => n as Degrees;
+
+// Geographic types
+interface LngLat       { lng: number; lat: number; }
+interface LngLatHeight { lng: number; lat: number; height: Meters; }
+```
+
+### Enums
+
+Every enum is a string-literal union — the literal value is the exact string the KMZ XML expects.
+
+```ts
+type FlyToWaylineMode      = "safely" | "pointToPoint";
+type FinishAction          = "goHome" | "noAction" | "autoLand" | "gotoFirstWaypoint";
+type ExitOnRCLost          = "goContinue" | "executeLostAction";
+type ExecuteRCLostAction   = "goBack" | "landing" | "hover";
+type TemplateType          = "waypoint" | "mapping2d" | "mapping3d" | "mappingStrip";
+type CoordinateMode        = "WGS84";
+type TemplateHeightMode    = "EGM96" | "relativeToStartPoint" | "aboveGroundLevel" | "realTimeFollowSurface";
+type ExecuteHeightMode     = "WGS84" | "relativeToStartPoint" | "realTimeFollowSurface";
+type WaypointTurnMode      = "coordinateTurn" | "toPointAndStopWithDiscontinuityCurvature" | "toPointAndStopWithContinuityCurvature" | "toPointAndPassWithContinuityCurvature";
+type WaypointHeadingMode   = "followWayline" | "manually" | "fixed" | "smoothTransition" | "towardPOI";
+type WaypointHeadingPathMode = "clockwise" | "counterClockwise" | "followBadArc";  // sic
+type GimbalPitchMode       = "manual" | "usePointSetting" | "fixed";
+type ShootType             = "time" | "distance";
+type MappingHeadingMode    = "fixed" | "followWayline";
+type LensType              = "wide" | "zoom" | "ir" | "narrow_band" | "visable";  // sic
+type ActionTriggerType     = "reachPoint" | "betweenAdjacentPoints" | "multipleTiming" | "multipleDistance";
+type ActionActuatorFunc    = /* 16 string literals — see Action union */;
+type RecordPointCloudOperate = "startRecord" | "pauseRecord" | "resumeRecord" | "stopRecord";
+type OrientedPhotoMode     = "normalPhoto" | "lowLightSmartShooting";
+type PositioningType       = "GPS" | "RTKBaseStation" | "QianXun" | "Custom";
+type FocusMode             = "firstPoint" | "custom";
+type MeteringMode          = "average" | "spot";
+type LidarReturnMode       = "singleReturnStrongest" | "dualReturn" | "tripleReturn";
+type LidarScanningMode     = "repetitive" | "nonRepetitive";
+```
+
+> ⚠️ Spec typos preserved verbatim: `visable` (intended `visible`), `followBadArc` (intended "shorter arc"). Do not autocorrect when serializing.
+
+### Drone & payload constants
+
+Lookup tables for the `droneEnumValue`/`droneSubEnumValue` and `payloadEnumValue`/`payloadPositionIndex` integer pairs. Spread them straight into a `MissionConfig`.
+
+```ts
+import { DroneEnum, PayloadEnum } from "@lumikmz/kmz";
+
+missionConfig: {
+  // ...
+  droneInfo: { ...DroneEnum.M3TD },        // → { droneEnumValue: 91, droneSubEnumValue: 1 }
+  payloadInfo: [{ ...PayloadEnum.M3TDCamera }], // → { payloadEnumValue: 81, payloadPositionIndex: 0 }
+}
+```
+
+`DroneEnum` keys: `M400`, `M350RTK`, `M300RTK`, `M30`, `M30T`, `M3E`, `M3T`, `M3TA`, `M3D`, `M3TD`, `M4D`, `M4TD`, `M4E`, `M4T`.
+
+`PayloadEnum` keys: per-model main cameras (`M3TDCamera`, `M30TCamera`, …), Zenmuse mounts (`ZenmuseH30T`, `ZenmuseH20T`, …), plus `FPVMatriceSeries`, `AuxiliaryM3xM4x`, `DockCamera`.
+
+For the full table see [`docs/kmz-types-spec.md` §11](../../docs/kmz-types-spec.md) — values come straight from [`docs/kmz/product-support.html`](../../docs/kmz/product-support.html).
+
+## How `plan()` dispatches
+
+The discriminator is **`template.Folder.templateType`** (nested one level under the root). Each variant of the `Template` union narrows to a concrete `Folder` type via the literal `templateType` field, so passing a `Template` to `plan()` is type-safe and exhaustive — adding a new template type would force a new switch arm.
+
+Internally, type guards at `src/plan/index.ts` route to one of five algorithms:
+
+- `planWaypoint` — Placemark-to-Placemark, resolving `useGlobalXxx` flags
+- `planMapping2d` — boustrophedon scan inside the Polygon
+- `planMapping3d` — five-Folder ortho+oblique pattern
+- `planMappingStrip` — LineString-to-LineString with optional per-vertex altitude
+
+Output is always a single `Waylines` object containing `1..n` `Folder` entries.
+
+## Compatibility
+
+[DJI WPML 1.0.2](https://developer.dji.com/doc/cloud-api-tutorial/en/feature-set/dji-wpml/template-kml.html) — see [`docs/kmz-types-spec.md`](../../docs/kmz-types-spec.md) for the distilled spec this package mirrors.
+
+## License
+
+[MIT](../../LICENSE)