@tileflow/static 0.1.0-alpha.3 → 0.1.0-alpha.30

package/dist/chunk-ALFVZ3PC.js

@@ -0,0 +1,600 @@
+import {
+  MAX_OVERLAY_LATITUDE,
+  isSupportedStaticSymbolCodePoint,
+  jsonByteLength,
+  normalizeStaticCoordinate,
+  normalizeStaticOverlay,
+  roundNumber,
+  staticPaddingSchema,
+  staticSceneLimits,
+  staticSceneSchema,
+  stripUndefined
+} from "./chunk-6DWVCK64.js";
+
+// src/auto-fit.ts
+import { z as z2 } from "zod";
+
+// src/errors.ts
+import { z } from "zod";
+var safeErrorTextSchema = z.string().min(1).max(512).refine(hasNoControlCharacters, { message: "Expected no control characters" });
+var safeErrorIdentifierSchema = z.string().min(1).max(128).regex(/^[A-Za-z0-9][A-Za-z0-9._:-]*$/u);
+var staticMapErrorResponseSchema = z.object({
+  code: safeErrorIdentifierSchema.optional(),
+  error: safeErrorTextSchema,
+  remainingUnits: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).optional(),
+  requestId: safeErrorIdentifierSchema.optional(),
+  requiredPlan: safeErrorIdentifierSchema.optional(),
+  retryable: z.boolean().optional()
+}).strip();
+var StaticMapError = class extends Error {
+  code;
+  remainingUnits;
+  requestId;
+  requiredPlan;
+  response;
+  retryable;
+  status;
+  constructor(response, status) {
+    const parsed = staticMapErrorResponseSchema.parse(response);
+    super(parsed.error);
+    this.name = "StaticMapError";
+    this.code = parsed.code ?? null;
+    this.remainingUnits = parsed.remainingUnits ?? null;
+    this.requestId = parsed.requestId ?? null;
+    this.requiredPlan = parsed.requiredPlan ?? null;
+    this.response = Object.freeze(parsed);
+    this.retryable = parsed.retryable ?? null;
+    this.status = status;
+  }
+};
+function hasNoControlCharacters(value) {
+  return !Array.from(value).some((character) => {
+    const codePoint = character.codePointAt(0) ?? 0;
+    return codePoint <= 31 || codePoint === 127;
+  });
+}
+
+// src/auto-fit.ts
+var autoFitOverlayReferenceSchema = z2.object({
+  id: z2.string().min(1).max(64),
+  index: z2.number().int().min(0).max(23),
+  type: z2.enum(["circle", "line", "marker", "polygon", "symbol"])
+}).strict();
+var autoFitViewportSchema = z2.object({
+  height: z2.number().int().min(64).max(1280),
+  width: z2.number().int().min(64).max(1280)
+}).strict();
+var autoFitDetailsSchema = z2.object({
+  overlay: autoFitOverlayReferenceSchema.optional(),
+  padding: staticPaddingSchema.optional(),
+  projection: z2.enum(["globe", "mercator"]).optional(),
+  requiredInsets: staticPaddingSchema.optional(),
+  ringIndex: z2.number().int().min(0).max(15).optional(),
+  segmentIndex: z2.number().int().min(0).max(1999).optional(),
+  viewport: autoFitViewportSchema.optional()
+}).strict();
+var staticOverlayInvalidDetailsSchema = z2.object({
+  latitude: z2.number().finite(),
+  limit: z2.literal(MAX_OVERLAY_LATITUDE),
+  overlay: autoFitOverlayReferenceSchema
+}).strict();
+var staticLabelUnsupportedDetailsSchema = z2.object({
+  codePoint: z2.number().int().min(0).max(1114111),
+  overlay: autoFitOverlayReferenceSchema.extend({ type: z2.literal("symbol") }).strict()
+}).strict();
+var staticIconUnavailableDetailsSchema = z2.object({
+  icon: z2.string().max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+  overlay: autoFitOverlayReferenceSchema.extend({ type: z2.literal("symbol") }).strict()
+}).strict();
+var staticSymbolTooLargeDetailsSchema = z2.object({
+  height: z2.number().finite().positive().max(16384),
+  limit: z2.literal(2048),
+  overlay: autoFitOverlayReferenceSchema.extend({ type: z2.literal("symbol") }).strict(),
+  width: z2.number().finite().positive().max(16384)
+}).strict();
+var autoFitErrorBase = {
+  error: z2.string().min(1).max(512),
+  retryable: z2.literal(false)
+};
+var staticMapRequestErrorResponseSchema = z2.discriminatedUnion("code", [
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("AUTO_FIT_EMPTY"),
+    reason: z2.literal("NO_FITTABLE_OVERLAYS")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("AUTO_FIT_AMBIGUOUS"),
+    details: autoFitDetailsSchema,
+    reason: z2.literal("ANTIMERIDIAN_WRAP_REQUIRED")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("AUTO_FIT_IMPOSSIBLE"),
+    details: autoFitDetailsSchema.optional(),
+    reason: z2.enum([
+      "GLOBE_NOT_SIMULTANEOUSLY_VISIBLE",
+      "INSUFFICIENT_VIEWPORT",
+      "CAMERA_UNRESOLVABLE",
+      "PROJECTED_FOOTPRINT_OUTSIDE_VIEWPORT"
+    ])
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_OVERLAY_INVALID"),
+    details: staticOverlayInvalidDetailsSchema,
+    reason: z2.literal("OVERLAY_LATITUDE_OUT_OF_RANGE")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_LABEL_UNSUPPORTED"),
+    details: staticLabelUnsupportedDetailsSchema,
+    reason: z2.literal("UNSUPPORTED_GLYPH")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_ICON_UNAVAILABLE"),
+    details: staticIconUnavailableDetailsSchema,
+    reason: z2.enum(["ICON_NOT_FOUND", "MANAGED_SPRITE_REQUIRED"])
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_PLACEMENT_UNAVAILABLE"),
+    reason: z2.literal("MAP_REDEPLOY_REQUIRED")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_SYMBOL_TOO_LARGE"),
+    details: staticSymbolTooLargeDetailsSchema,
+    reason: z2.literal("COMPOSED_IMAGE_TOO_LARGE")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_ATTRIBUTION_UNSUPPORTED"),
+    reason: z2.enum(["UNSUPPORTED_DECLARATION", "UNSUPPORTED_GLYPH"])
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_ATTRIBUTION_TOO_LARGE"),
+    reason: z2.literal("CONTENT_LIMIT_EXCEEDED")
+  }).strict(),
+  z2.object({
+    ...autoFitErrorBase,
+    code: z2.literal("STATIC_MAP_ATTRIBUTION_DOES_NOT_FIT"),
+    reason: z2.literal("BLOCK_DOES_NOT_FIT")
+  }).strict()
+]);
+var StaticMapRequestError = class extends StaticMapError {
+  code;
+  details;
+  reason;
+  retryable = false;
+  status;
+  constructor(response, status = 422) {
+    super(response, status);
+    this.name = "StaticMapRequestError";
+    this.code = response.code;
+    this.details = "details" in response ? response.details : void 0;
+    this.reason = response.reason;
+    this.status = status;
+  }
+};
+var staticAutoFitPlanSchema = z2.object({
+  bounds: z2.tuple([
+    z2.number().finite(),
+    z2.number().finite().min(-90).max(90),
+    z2.number().finite(),
+    z2.number().finite().min(-90).max(90)
+  ]),
+  longitudeOffsets: z2.array(z2.number().int().min(-360).max(360)).max(24),
+  nominalInsets: staticPaddingSchema,
+  requiredInsets: staticPaddingSchema
+}).strict();
+function analyzeStaticAutoFit(scene) {
+  if (scene.camera.type !== "auto") {
+    throw new Error("Static auto-fit analysis requires an auto camera");
+  }
+  if (scene.overlays.length === 0) {
+    return failure({
+      code: "AUTO_FIT_EMPTY",
+      error: "Auto-fit requires at least one overlay",
+      reason: "NO_FITTABLE_OVERLAYS",
+      retryable: false
+    });
+  }
+  const components = [];
+  let south = Number.POSITIVE_INFINITY;
+  let north = Number.NEGATIVE_INFINITY;
+  let nominalExpansion = 0;
+  for (const [overlayIndex, overlay] of scene.overlays.entries()) {
+    const coordinates = overlayCoordinates(overlay);
+    const ambiguity = findAmbiguousSegment(overlay);
+    if (ambiguity) {
+      return failure({
+        code: "AUTO_FIT_AMBIGUOUS",
+        details: {
+          overlay: {
+            id: overlay.id ?? `overlay-${overlayIndex + 1}`,
+            index: overlayIndex,
+            type: overlay.type
+          },
+          ...ambiguity.ringIndex === void 0 ? {} : { ringIndex: ambiguity.ringIndex },
+          segmentIndex: ambiguity.segmentIndex
+        },
+        error: `Overlay overlays.${overlayIndex} requires an explicit antimeridian wrap decision`,
+        reason: "ANTIMERIDIAN_WRAP_REQUIRED",
+        retryable: false
+      });
+    }
+    const longitudes = coordinates.map(([longitude]) => longitude);
+    components.push({
+      east: Math.max(...longitudes),
+      overlayIndex,
+      west: Math.min(...longitudes)
+    });
+    for (const [, latitude] of coordinates) {
+      south = Math.min(south, latitude);
+      north = Math.max(north, latitude);
+    }
+    nominalExpansion = Math.max(nominalExpansion, nominalOverlayExpansion(overlay));
+  }
+  const longitudePlan = fitLongitudeComponents(components);
+  const nominalInset = Math.ceil(nominalExpansion);
+  const nominalInsets = allSides(nominalInset);
+  const padding = normalizedPadding(scene.camera.padding, scene.size);
+  if ([padding.bottom, padding.left, padding.right, padding.top].some(
+    (value) => !Number.isSafeInteger(value + nominalInset)
+  )) {
+    return failure({
+      code: "AUTO_FIT_IMPOSSIBLE",
+      details: {
+        padding,
+        viewport: { height: scene.size.height, width: scene.size.width }
+      },
+      error: "Auto-fit nominal footprint leaves no usable viewport",
+      reason: "INSUFFICIENT_VIEWPORT",
+      retryable: false
+    });
+  }
+  const requiredInsets = {
+    bottom: padding.bottom + nominalInset,
+    left: padding.left + nominalInset,
+    right: padding.right + nominalInset,
+    top: padding.top + nominalInset
+  };
+  if (requiredInsets.left + requiredInsets.right >= scene.size.width || requiredInsets.top + requiredInsets.bottom >= scene.size.height) {
+    return failure({
+      code: "AUTO_FIT_IMPOSSIBLE",
+      details: {
+        padding,
+        requiredInsets,
+        viewport: { height: scene.size.height, width: scene.size.width }
+      },
+      error: "Auto-fit nominal footprint leaves no usable viewport",
+      reason: "INSUFFICIENT_VIEWPORT",
+      retryable: false
+    });
+  }
+  return {
+    ok: true,
+    plan: {
+      bounds: [
+        roundNumber(longitudePlan.west),
+        roundNumber(south),
+        roundNumber(longitudePlan.east),
+        roundNumber(north)
+      ],
+      longitudeOffsets: longitudePlan.offsets,
+      nominalInsets,
+      requiredInsets
+    }
+  };
+}
+function failure(response) {
+  return { ...response, ok: false };
+}
+function overlayCoordinates(overlay) {
+  if (overlay.type === "circle" || overlay.type === "marker" || overlay.type === "symbol") {
+    return [overlay.coordinate];
+  }
+  if (overlay.type === "line") {
+    return overlay.coordinates;
+  }
+  return overlay.coordinates.flat();
+}
+function findAmbiguousSegment(overlay) {
+  if (overlay.type === "circle" || overlay.type === "marker" || overlay.type === "symbol")
+    return null;
+  const paths = overlay.type === "line" ? [overlay.coordinates] : overlay.coordinates;
+  for (const [ringIndex, path] of paths.entries()) {
+    for (let segmentIndex = 0; segmentIndex < path.length - 1; segmentIndex += 1) {
+      const start = path[segmentIndex];
+      const end = path[segmentIndex + 1];
+      if (start && end && Math.abs(end[0] - start[0]) >= 180) {
+        return {
+          ...overlay.type === "polygon" ? { ringIndex } : {},
+          segmentIndex
+        };
+      }
+    }
+  }
+  return null;
+}
+function nominalOverlayExpansion(overlay) {
+  if (overlay.type === "circle" || overlay.type === "marker") {
+    return overlay.radius + overlay.strokeWidth;
+  }
+  if (overlay.type === "symbol") return 0;
+  if (overlay.type === "line") {
+    return overlay.width / 2 + 0.5;
+  }
+  return overlay.stroke && overlay.strokeWidth > 0 ? overlay.strokeWidth / 2 + 0.5 : 0;
+}
+function fitLongitudeComponents(components) {
+  const candidates = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    candidates.add(toCircle(component.west));
+    candidates.add(toCircle(component.east));
+  }
+  let best;
+  for (const cut of [...candidates].sort((left, right) => left - right)) {
+    const assignedStarts = [];
+    let west = Number.POSITIVE_INFINITY;
+    let east = Number.NEGATIVE_INFINITY;
+    let valid = true;
+    for (const component of components) {
+      const width = component.east - component.west;
+      let start = toCircle(component.west);
+      if (start < cut) start += 360;
+      const end = start + width;
+      if (end > cut + 360 + 1e-9) {
+        valid = false;
+        break;
+      }
+      assignedStarts.push(start);
+      west = Math.min(west, start);
+      east = Math.max(east, end);
+    }
+    if (!valid) continue;
+    const span = east - west;
+    const canonicalWest2 = canonicalLongitude(west - 180);
+    const bestCanonicalWest = best ? canonicalLongitude(best.west - 180) : Number.POSITIVE_INFINITY;
+    if (!best || span < best.span - 1e-9 || Math.abs(span - best.span) <= 1e-9 && canonicalWest2 < bestCanonicalWest) {
+      best = { assignedStarts, east, span, west };
+    }
+  }
+  if (!best) {
+    const west = Math.min(...components.map((component) => component.west));
+    const east = Math.max(...components.map((component) => component.east));
+    return { east, offsets: components.map(() => 0), west };
+  }
+  const unshiftedWest = best.west - 180;
+  const canonicalWest = canonicalLongitude(unshiftedWest);
+  const globalOffset = canonicalWest - unshiftedWest;
+  const offsets = components.map((component, index) => {
+    const assignedLongitude = (best?.assignedStarts[index] ?? 0) - 180 + globalOffset;
+    return Math.round(assignedLongitude - component.west);
+  });
+  return {
+    east: canonicalWest + best.span,
+    offsets,
+    west: canonicalWest
+  };
+}
+function toCircle(longitude) {
+  const value = (longitude + 180) % 360;
+  return value < 0 ? value + 360 : value;
+}
+function canonicalLongitude(longitude) {
+  const value = ((longitude + 180) % 360 + 360) % 360;
+  return value - 180;
+}
+function allSides(value) {
+  return { bottom: value, left: value, right: value, top: value };
+}
+function normalizedPadding(padding, size) {
+  if (padding === void 0) {
+    return allSides(Math.min(32, Math.ceil(Math.min(size.width, size.height) * 0.05)));
+  }
+  if (typeof padding === "number") return allSides(padding);
+  return {
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0,
+    right: padding.right ?? 0,
+    top: padding.top ?? 0
+  };
+}
+function autoFitErrorResponse(failure2) {
+  const { ok: _ok, ...response } = failure2;
+  return response;
+}
+function findStaticOverlayLatitudeFailure(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const overlays = input.overlays;
+  if (!Array.isArray(overlays)) return null;
+  for (const [index, candidate] of overlays.entries()) {
+    if (index >= staticSceneLimits.maxOverlays) break;
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+    const overlay = candidate;
+    const type = overlay.type;
+    if (!["circle", "line", "marker", "polygon", "symbol"].includes(String(type))) continue;
+    const coordinates = type === "circle" || type === "marker" || type === "symbol" ? [overlay.coordinate] : overlayCoordinateCandidates(type, overlay.coordinates);
+    for (const coordinate of coordinates) {
+      if (!Array.isArray(coordinate) || coordinate.length !== 2 || typeof coordinate[1] !== "number" || !Number.isFinite(coordinate[1]) || Math.abs(coordinate[1]) <= MAX_OVERLAY_LATITUDE) {
+        continue;
+      }
+      const id = typeof overlay.id === "string" && overlay.id.trim() ? overlay.id.trim() : `overlay-${index + 1}`;
+      const response = {
+        code: "STATIC_OVERLAY_INVALID",
+        details: {
+          latitude: coordinate[1],
+          limit: MAX_OVERLAY_LATITUDE,
+          overlay: {
+            id: id.slice(0, 64),
+            index,
+            type
+          }
+        },
+        error: `Overlay overlays.${index} latitude ${coordinate[1]} exceeds the supported \xB1${MAX_OVERLAY_LATITUDE}\xB0 range`,
+        reason: "OVERLAY_LATITUDE_OUT_OF_RANGE",
+        retryable: false
+      };
+      return { ...response, ok: false };
+    }
+  }
+  return null;
+}
+function findStaticSymbolLabelGlyphFailure(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) return null;
+  const overlays = input.overlays;
+  if (!Array.isArray(overlays)) return null;
+  for (const [index, candidate] of overlays.entries()) {
+    if (index >= staticSceneLimits.maxOverlays) break;
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) continue;
+    const overlay = candidate;
+    if (overlay.type !== "symbol") continue;
+    const label = overlay.label;
+    const text = typeof label === "string" ? label : label && typeof label === "object" && !Array.isArray(label) ? label.text : void 0;
+    if (typeof text !== "string") continue;
+    const unsupported = Array.from(text).find(
+      (character) => !isSupportedStaticSymbolCodePoint(character.codePointAt(0))
+    );
+    if (!unsupported) continue;
+    const codePoint = unsupported.codePointAt(0);
+    const id = typeof overlay.id === "string" && overlay.id.trim() ? overlay.id.trim() : `overlay-${index + 1}`;
+    return {
+      code: "STATIC_MAP_LABEL_UNSUPPORTED",
+      details: {
+        codePoint,
+        overlay: { id: id.slice(0, 64), index, type: "symbol" }
+      },
+      error: `Overlay overlays.${index} label contains unsupported glyph U+${codePoint.toString(16).toUpperCase().padStart(4, "0")}`,
+      ok: false,
+      reason: "UNSUPPORTED_GLYPH",
+      retryable: false
+    };
+  }
+  return null;
+}
+function overlayCoordinateCandidates(type, value) {
+  if (!Array.isArray(value)) return [];
+  if (type === "line") {
+    return value.slice(0, staticSceneLimits.maxPathCoordinates);
+  }
+  return value.slice(0, 16).flatMap(
+    (ring) => Array.isArray(ring) ? ring.slice(0, staticSceneLimits.maxPathCoordinates) : []
+  );
+}
+
+// src/scene.ts
+function validateStaticScene(input) {
+  const overlayLatitudeFailure = findStaticOverlayLatitudeFailure(input);
+  if (overlayLatitudeFailure) return overlayLatitudeFailure;
+  const labelGlyphFailure = findStaticSymbolLabelGlyphFailure(input);
+  if (labelGlyphFailure) return labelGlyphFailure;
+  const parsed = staticSceneSchema.safeParse(input);
+  if (!parsed.success) {
+    return {
+      error: parsed.error.issues.map((issue) => `${issue.path.join(".") || "scene"}: ${issue.message}`).join("; "),
+      ok: false
+    };
+  }
+  if (jsonByteLength(parsed.data.overlays) > staticSceneLimits.maxGeoJsonBytes) {
+    return {
+      error: `overlays exceed ${staticSceneLimits.maxGeoJsonBytes} bytes`,
+      ok: false
+    };
+  }
+  const scene = normalizeParsedStaticScene(parsed.data);
+  if (scene.camera.type === "auto") {
+    const analysis = analyzeStaticAutoFit(scene);
+    if (!analysis.ok) return analysis;
+  }
+  return { ok: true, scene };
+}
+function normalizeStaticScene(scene) {
+  const overlayLatitudeFailure = findStaticOverlayLatitudeFailure(scene);
+  if (overlayLatitudeFailure) {
+    const { ok: _ok, ...response } = overlayLatitudeFailure;
+    throw new StaticMapRequestError(response);
+  }
+  const labelGlyphFailure = findStaticSymbolLabelGlyphFailure(scene);
+  if (labelGlyphFailure) {
+    const { ok: _ok, ...response } = labelGlyphFailure;
+    throw new StaticMapRequestError(response);
+  }
+  const normalized = normalizeParsedStaticScene(staticSceneSchema.parse(scene));
+  if (normalized.camera.type === "auto") {
+    const analysis = analyzeStaticAutoFit(normalized);
+    if (!analysis.ok) {
+      throw new StaticMapRequestError(autoFitErrorResponse(analysis));
+    }
+  }
+  return normalized;
+}
+function normalizeParsedStaticScene(parsed) {
+  return stripUndefined({
+    ...parsed.attribution && Object.keys(parsed.attribution).length > 0 ? {
+      attribution: parsed.attribution.mode === "external" ? { mode: "external" } : stripUndefined({
+        mode: parsed.attribution.mode,
+        position: parsed.attribution.position
+      })
+    } : {},
+    camera: parsed.camera.type === "center" ? {
+      bearing: roundNumber(parsed.camera.bearing ?? 0),
+      center: normalizeStaticCoordinate(parsed.camera.center),
+      type: "center",
+      zoom: roundNumber(parsed.camera.zoom)
+    } : parsed.camera.type === "bounds" ? {
+      bearing: roundNumber(parsed.camera.bearing ?? 0),
+      bounds: parsed.camera.bounds.map(roundNumber),
+      padding: parsed.camera.padding ?? 32,
+      type: "bounds"
+    } : {
+      bearing: roundNumber(parsed.camera.bearing ?? 0),
+      maxZoom: roundNumber(parsed.camera.maxZoom ?? 16),
+      padding: normalizeAutoPadding(parsed.camera.padding, parsed.size),
+      type: "auto"
+    },
+    ...parsed.format && parsed.format !== "png" ? { format: parsed.format } : {},
+    map: parsed.map,
+    overlays: parsed.overlays.map(
+      (overlay, index) => normalizeStaticOverlay({
+        ...overlay,
+        id: overlay.id ?? `overlay-${index + 1}`
+      })
+    ),
+    size: {
+      dpr: parsed.size.dpr ?? 1,
+      height: parsed.size.height,
+      width: parsed.size.width
+    },
+    theme: parsed.theme
+  });
+}
+function normalizeAutoPadding(padding, size) {
+  if (padding === void 0) {
+    const value = Math.min(32, Math.ceil(Math.min(size.width, size.height) * 0.05));
+    return { bottom: value, left: value, right: value, top: value };
+  }
+  if (typeof padding === "number") {
+    return { bottom: padding, left: padding, right: padding, top: padding };
+  }
+  return {
+    bottom: padding.bottom ?? 0,
+    left: padding.left ?? 0,
+    right: padding.right ?? 0,
+    top: padding.top ?? 0
+  };
+}
+
+export {
+  staticMapErrorResponseSchema,
+  StaticMapError,
+  staticMapRequestErrorResponseSchema,
+  StaticMapRequestError,
+  staticAutoFitPlanSchema,
+  analyzeStaticAutoFit,
+  validateStaticScene,
+  normalizeStaticScene
+};