@tileflow/static 0.1.0-alpha.17 → 0.1.0-alpha.19

package/dist/index.js

@@ -1,568 +1,39 @@
-// src/index.ts
-import { z } from "zod";
-var staticSceneSchemaVersion = 1;
-var staticRendererSchemaVersion = 1;
-var staticSceneLimits = {
-  maxDimension: 1280,
-  maxGeoJsonBytes: 96e3,
-  maxOverlays: 24,
-  maxPathCoordinates: 2e3,
-  maxPhysicalPixels: 1280 * 1280,
-  minDimension: 64
-};
-var coordinateSchema = z.tuple([z.number().finite(), z.number().finite()]).refine(([lng, lat]) => lng >= -180 && lng <= 180 && lat >= -90 && lat <= 90, {
-  message: "Expected [lng, lat] within world bounds"
-});
-var colorSchema = z.string().regex(/^#(?:[0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/, {
-  message: "Expected a hex color like #C6A15B"
-});
-var sizeSchema = z.object({
-  dpr: z.literal(1).optional(),
-  height: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension),
-  width: z.number().int().min(staticSceneLimits.minDimension).max(staticSceneLimits.maxDimension)
-}).refine(
-  (size) => size.width * size.height * (size.dpr ?? 1) <= staticSceneLimits.maxPhysicalPixels,
-  {
-    message: "Static map exceeds the maximum render pixel budget"
-  }
-);
-var centerCameraSchema = z.object({
-  bearing: z.number().finite().min(-180).max(180).optional(),
-  center: coordinateSchema,
-  type: z.literal("center"),
-  zoom: z.number().finite().min(0).max(22)
-});
-var boundsCameraSchema = z.object({
-  bearing: z.number().finite().min(-180).max(180).optional(),
-  bounds: z.tuple([z.number().finite(), z.number().finite(), z.number().finite(), z.number().finite()]).refine(
-    ([west, south, east, north]) => west >= -180 && west <= 180 && east >= -180 && east <= 180 && south >= -90 && south <= 90 && north >= -90 && north <= 90 && west !== east && south !== north,
-    { message: "Expected bounds as [west, south, east, north]" }
-  ),
-  padding: z.number().int().min(0).max(256).optional(),
-  type: z.literal("bounds")
-}).refine((camera) => camera.bounds[3] > camera.bounds[1], {
-  message: "Bounds north must be greater than south"
-});
-var lineOverlaySchema = z.object({
-  color: colorSchema.default("#C6A15B"),
-  coordinates: z.array(coordinateSchema).min(2).max(staticSceneLimits.maxPathCoordinates),
-  id: z.string().trim().min(1).max(64).optional(),
-  opacity: z.number().finite().min(0).max(1).default(1),
-  type: z.literal("line"),
-  width: z.number().finite().min(0.5).max(32).default(4)
-});
-var circleOverlaySchema = z.object({
-  color: colorSchema.default("#C6A15B"),
-  coordinate: coordinateSchema,
-  id: z.string().trim().min(1).max(64).optional(),
-  opacity: z.number().finite().min(0).max(1).default(1),
-  radius: z.number().finite().min(1).max(64).default(6),
-  strokeColor: colorSchema.optional(),
-  strokeWidth: z.number().finite().min(0).max(16).default(0),
-  type: z.literal("circle")
-});
-var markerOverlaySchema = z.object({
-  color: colorSchema.default("#C6A15B"),
-  coordinate: coordinateSchema,
-  id: z.string().trim().min(1).max(64).optional(),
-  radius: z.number().finite().min(2).max(64).default(8),
-  strokeColor: colorSchema.default("#ffffff"),
-  strokeWidth: z.number().finite().min(0).max(16).default(2),
-  type: z.literal("marker")
-});
-var polygonRingSchema = z.array(coordinateSchema).min(4).max(staticSceneLimits.maxPathCoordinates).refine(
-  (ring) => {
-    const first = ring[0];
-    const last = ring[ring.length - 1];
-    return Boolean(first && last && first[0] === last[0] && first[1] === last[1]);
-  },
-  { message: "Polygon rings must end at their starting coordinate" }
-);
-var polygonOverlaySchema = z.object({
-  coordinates: z.array(polygonRingSchema).min(1).max(16),
-  fill: colorSchema.default("#C6A15B"),
-  id: z.string().trim().min(1).max(64).optional(),
-  opacity: z.number().finite().min(0).max(1).default(0.28),
-  stroke: colorSchema.optional(),
-  strokeWidth: z.number().finite().min(0).max(16).default(0),
-  type: z.literal("polygon")
-});
-var staticOverlaySchema = z.discriminatedUnion("type", [
-  lineOverlaySchema,
-  circleOverlaySchema,
-  markerOverlaySchema,
-  polygonOverlaySchema
-]);
-var staticSceneSchema = z.object({
-  camera: z.discriminatedUnion("type", [centerCameraSchema, boundsCameraSchema]),
-  map: z.string().trim().min(1).max(128),
-  overlays: z.array(staticOverlaySchema).max(staticSceneLimits.maxOverlays).default([]),
-  size: sizeSchema
-});
-var staticRenderManifestSchema = z.object({
-  mapId: z.string().trim().min(1).max(128),
-  rendererVersion: z.string().trim().min(1).max(64),
-  schemaVersion: z.literal(staticRendererSchemaVersion),
-  scene: staticSceneSchema,
-  styleId: z.string().trim().min(1).max(128).optional(),
-  styleRevision: z.string().trim().min(1).max(128),
-  styleUrl: z.string().trim().url().max(512).refine((value) => /^https?:\/\//.test(value), {
-    message: "Expected an http(s) style URL"
-  })
-});
-var staticMapIdempotencyKeyPattern = /^[A-Za-z0-9][A-Za-z0-9._:-]{7,127}$/;
-var staticMapReadyResultSchema = z.object({
-  cached: z.boolean(),
-  hash: z.string().regex(/^[A-Za-z0-9_-]{43}$/),
-  imageUrl: z.string().trim().url().max(2048).refine(isSafeHttpUrl, { message: "Expected an http(s) URL without credentials" }),
-  operationId: z.string().min(20).max(68),
-  remainingUnits: z.number().int().nonnegative(),
-  status: z.literal("ready"),
-  unitCost: z.literal(15)
-}).strict();
-var staticMapProcessingResultSchema = z.object({
-  operationId: z.string().min(20).max(68),
-  retryAfterMs: z.number().int().min(0).max(5e3),
-  status: z.literal("processing")
-}).strict();
-function validateStaticMapIdempotencyKey(value) {
-  if (typeof value !== "string" || !staticMapIdempotencyKeyPattern.test(value)) {
-    return {
-      error: "Idempotency key must contain 8-128 ASCII letters, digits, dot, underscore, colon, or hyphen and start with a letter or digit",
-      ok: false
-    };
-  }
-  return { key: value, ok: true };
-}
-function createStaticMapIdempotencyKey() {
-  const key = `static_${crypto.randomUUID()}`;
-  if (!validateStaticMapIdempotencyKey(key).ok) {
-    throw new Error("Unable to create a valid Tileflow Static Maps idempotency key");
-  }
-  return key;
-}
-function line(input) {
-  return normalizeOverlay({ ...input, type: "line" });
-}
-function circle(input) {
-  return normalizeOverlay({ ...input, type: "circle" });
-}
-function marker(input) {
-  return normalizeOverlay({ ...input, type: "marker" });
-}
-function polygon(input) {
-  return normalizeOverlay({ ...input, type: "polygon" });
-}
-function validateStaticScene(input) {
-  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
-    };
-  }
-  return { ok: true, scene: normalizeStaticScene(parsed.data) };
-}
-function validateStaticRenderManifest(input) {
-  const parsed = staticRenderManifestSchema.safeParse(input);
-  if (!parsed.success) {
-    return {
-      error: parsed.error.issues.map((issue) => `${issue.path.join(".") || "manifest"}: ${issue.message}`).join("; "),
-      ok: false
-    };
-  }
-  const sceneValidation = validateStaticScene(parsed.data.scene);
-  if (!sceneValidation.ok) {
-    return sceneValidation;
-  }
-  return {
-    manifest: {
-      ...parsed.data,
-      scene: sceneValidation.scene
-    },
-    ok: true
-  };
-}
-function normalizeStaticScene(scene) {
-  const parsed = staticSceneSchema.parse(scene);
-  return stripUndefined({
-    camera: parsed.camera.type === "center" ? {
-      bearing: roundNumber(parsed.camera.bearing ?? 0),
-      center: normalizeCoordinate(parsed.camera.center),
-      type: "center",
-      zoom: roundNumber(parsed.camera.zoom)
-    } : {
-      bearing: roundNumber(parsed.camera.bearing ?? 0),
-      bounds: parsed.camera.bounds.map(roundNumber),
-      padding: parsed.camera.padding ?? 32,
-      type: "bounds"
-    },
-    map: parsed.map,
-    overlays: parsed.overlays.map(
-      (overlay, index) => normalizeOverlay({
-        ...overlay,
-        id: overlay.id ?? `overlay-${index + 1}`
-      })
-    ),
-    size: {
-      dpr: parsed.size.dpr ?? 1,
-      height: parsed.size.height,
-      width: parsed.size.width
-    }
-  });
-}
-function createRenderManifest(input) {
-  return staticRenderManifestSchema.parse(
-    stripUndefined({
-      mapId: input.mapId,
-      rendererVersion: input.rendererVersion,
-      schemaVersion: staticRendererSchemaVersion,
-      scene: normalizeStaticScene({
-        ...input.scene,
-        map: input.mapId
-      }),
-      styleId: input.styleId,
-      styleRevision: input.styleRevision,
-      styleUrl: input.styleUrl
-    })
-  );
-}
-async function hashRenderManifest(manifest) {
-  const normalized = staticRenderManifestSchema.parse({
-    ...manifest,
-    scene: normalizeStaticScene(manifest.scene)
-  });
-  const bytes = new TextEncoder().encode(stableStringify(normalized));
-  const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return base64Url(new Uint8Array(digest));
-}
-async function hashStaticSceneRequest(scene) {
-  const validation = validateStaticScene(scene);
-  if (!validation.ok) throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
-  return hashStableValue(validation.scene);
-}
-function compileStaticOverlays(overlays) {
-  const sources = {};
-  const layers = [];
-  for (const [index, overlay] of overlays.entries()) {
-    const id = safeLayerId(`overlay-${index + 1}-${overlay.id ?? overlay.type}`);
-    const sourceId = `${id}-source`;
-    if (overlay.type === "line") {
-      sources[sourceId] = {
-        data: feature("LineString", overlay.coordinates),
-        type: "geojson"
-      };
-      layers.push({
-        id,
-        layout: { "line-cap": "round", "line-join": "round" },
-        paint: {
-          "line-color": overlay.color,
-          "line-opacity": overlay.opacity,
-          "line-width": overlay.width
-        },
-        source: sourceId,
-        type: "line"
-      });
-      continue;
-    }
-    if (overlay.type === "polygon") {
-      sources[sourceId] = {
-        data: feature("Polygon", overlay.coordinates),
-        type: "geojson"
-      };
-      layers.push({
-        id,
-        paint: {
-          "fill-color": overlay.fill,
-          "fill-opacity": overlay.opacity
-        },
-        source: sourceId,
-        type: "fill"
-      });
-      if (overlay.stroke && overlay.strokeWidth > 0) {
-        layers.push({
-          id: `${id}-stroke`,
-          layout: { "line-cap": "round", "line-join": "round" },
-          paint: {
-            "line-color": overlay.stroke,
-            "line-width": overlay.strokeWidth
-          },
-          source: sourceId,
-          type: "line"
-        });
-      }
-      continue;
-    }
-    sources[sourceId] = {
-      data: feature("Point", overlay.coordinate),
-      type: "geojson"
-    };
-    layers.push({
-      id,
-      paint: {
-        "circle-color": overlay.color,
-        "circle-opacity": overlay.type === "circle" ? overlay.opacity : 1,
-        "circle-radius": overlay.radius,
-        "circle-stroke-color": overlay.strokeColor ?? overlay.color,
-        "circle-stroke-width": overlay.strokeWidth
-      },
-      source: sourceId,
-      type: "circle"
-    });
-  }
-  return { layers, sources };
-}
-async function createStaticMap(scene, options) {
-  return requestStaticMap(scene, options, "/v1/static/maps");
-}
-async function precacheStaticMap(scene, options) {
-  return requestStaticMap(scene, options, "/v1/static/maps/precache");
-}
-async function requestStaticMap(scene, options, path) {
-  const validation = validateStaticScene(scene);
-  if (!validation.ok) {
-    throw new Error(`Invalid Tileflow static scene: ${validation.error}`);
-  }
-  const idempotency = validateStaticMapIdempotencyKey(options.idempotencyKey);
-  if (!idempotency.ok) {
-    throw new Error(`Invalid Tileflow Static Maps idempotency key: ${idempotency.error}`);
-  }
-  const maxWaitMs = boundedClientDuration(options.maxWaitMs, 3e4, 100, 12e4, "maxWaitMs");
-  const pollIntervalMs = boundedClientDuration(
-    options.pollIntervalMs,
-    500,
-    0,
-    5e3,
-    "pollIntervalMs"
-  );
-  const fetcher = options.fetch ?? fetch;
-  const apiUrl = normalizeUrl(options.apiUrl ?? "https://api.tileflow.dev");
-  const headers = {
-    "Content-Type": "application/json",
-    "Idempotency-Key": idempotency.key
-  };
-  if (options.apiKey) {
-    headers.Authorization = `Bearer ${options.apiKey}`;
-  }
-  return runWithinStaticMapBudget(maxWaitMs, options.signal, async (signal) => {
-    const body = JSON.stringify(validation.scene);
-    let operationId = null;
-    while (true) {
-      const response = await fetcher(`${apiUrl}${path}`, {
-        body,
-        headers,
-        method: "POST",
-        signal
-      });
-      throwIfAborted(signal);
-      if (!response.ok) {
-        const error = await response.text();
-        throwIfAborted(signal);
-        throw new Error(`Tileflow static map failed: ${response.status} ${error}`);
-      }
-      const json = await readJsonResponse(response);
-      throwIfAborted(signal);
-      if (response.status !== 202) {
-        const parsed = staticMapReadyResultSchema.safeParse(json);
-        if (!parsed.success) {
-          throw new Error(
-            `Tileflow static map returned an invalid response: ${parsed.error.message}`
-          );
-        }
-        assertStaticMapOperationIdentity(operationId, parsed.data.operationId);
-        return parsed.data;
-      }
-      const pending = staticMapProcessingResultSchema.safeParse(json);
-      if (!pending.success) {
-        throw new Error(
-          `Tileflow static map returned an invalid response: ${pending.error.message}`
-        );
-      }
-      assertStaticMapOperationIdentity(operationId, pending.data.operationId);
-      operationId ??= pending.data.operationId;
-      await delay(Math.max(pollIntervalMs, pending.data.retryAfterMs), signal);
-    }
-  });
-}
-function stableStringify(value) {
-  return JSON.stringify(sortJson(value));
-}
-function normalizeOverlay(overlay) {
-  const parsed = staticOverlaySchema.parse(overlay);
-  const normalized = stripUndefined({ ...parsed });
-  if ("coordinate" in normalized) {
-    normalized.coordinate = normalizeCoordinate(normalized.coordinate);
-  }
-  if ("coordinates" in normalized) {
-    normalized.coordinates = normalizeCoordinates(normalized.coordinates);
-  }
-  return normalized;
-}
-function normalizeCoordinates(value) {
-  if (!Array.isArray(value)) {
-    return value;
-  }
-  if (value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") {
-    return normalizeCoordinate(value);
-  }
-  return value.map(normalizeCoordinates);
-}
-function normalizeCoordinate(coordinate) {
-  return [roundNumber(coordinate[0]), roundNumber(coordinate[1])];
-}
-function roundNumber(value) {
-  return Number(value.toFixed(6));
-}
-function stripUndefined(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return value;
-  }
-  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== void 0));
-}
-function sortJson(value) {
-  if (Array.isArray(value)) {
-    return value.map(sortJson);
-  }
-  if (value && typeof value === "object") {
-    return Object.fromEntries(
-      Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, entry]) => [key, sortJson(entry)])
-    );
-  }
-  return value;
-}
-function feature(type, coordinates) {
-  return {
-    geometry: { coordinates, type },
-    properties: {},
-    type: "Feature"
-  };
-}
-function safeLayerId(value) {
-  return value.replace(/[^a-zA-Z0-9_-]/g, "-").slice(0, 80);
-}
-function jsonByteLength(value) {
-  return new TextEncoder().encode(JSON.stringify(value)).length;
-}
-function base64Url(bytes) {
-  let binary = "";
-  for (const byte of bytes) {
-    binary += String.fromCharCode(byte);
-  }
-  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-}
-async function hashStableValue(value) {
-  const bytes = new TextEncoder().encode(stableStringify(value));
-  const digest = await crypto.subtle.digest("SHA-256", bytes);
-  return base64Url(new Uint8Array(digest));
-}
-function boundedClientDuration(value, fallback, minimum, maximum, name) {
-  const resolved = value ?? fallback;
-  if (!Number.isSafeInteger(resolved) || resolved < minimum || resolved > maximum) {
-    throw new Error(
-      `Tileflow Static Maps ${name} must be an integer from ${minimum} to ${maximum}`
-    );
-  }
-  return resolved;
-}
-async function readJsonResponse(response) {
-  try {
-    return await response.json();
-  } catch {
-    throw new Error("Tileflow static map returned an invalid response: expected JSON");
-  }
-}
-async function runWithinStaticMapBudget(maxWaitMs, externalSignal, operation) {
-  const controller = new AbortController();
-  const timeoutError = new Error(`Tileflow static map timed out after ${maxWaitMs}ms`);
-  const abortFromCaller = () => controller.abort(externalSignal?.reason);
-  if (externalSignal?.aborted) {
-    abortFromCaller();
-  } else {
-    externalSignal?.addEventListener("abort", abortFromCaller, { once: true });
-  }
-  const timeout = setTimeout(() => controller.abort(timeoutError), maxWaitMs);
-  try {
-    throwIfAborted(controller.signal);
-    const pending = operation(controller.signal);
-    return await raceWithAbort(pending, controller.signal);
-  } finally {
-    clearTimeout(timeout);
-    externalSignal?.removeEventListener("abort", abortFromCaller);
-  }
-}
-function delay(milliseconds, signal) {
-  if (milliseconds === 0) {
-    throwIfAborted(signal);
-    return Promise.resolve();
-  }
-  return new Promise((resolve, reject) => {
-    const timeout = setTimeout(() => {
-      signal.removeEventListener("abort", onAbort);
-      resolve();
-    }, milliseconds);
-    const onAbort = () => {
-      clearTimeout(timeout);
-      reject(abortReason(signal));
-    };
-    if (signal.aborted) {
-      onAbort();
-    } else {
-      signal.addEventListener("abort", onAbort, { once: true });
-    }
-  });
-}
-function raceWithAbort(operation, signal) {
-  if (signal.aborted) return Promise.reject(abortReason(signal));
-  return new Promise((resolve, reject) => {
-    const onAbort = () => {
-      cleanup();
-      reject(abortReason(signal));
-    };
-    const cleanup = () => signal.removeEventListener("abort", onAbort);
-    signal.addEventListener("abort", onAbort, { once: true });
-    operation.then(
-      (value) => {
-        cleanup();
-        resolve(value);
-      },
-      (error) => {
-        cleanup();
-        reject(error);
-      }
-    );
-  });
-}
-function throwIfAborted(signal) {
-  if (signal.aborted) throw abortReason(signal);
-}
-function abortReason(signal) {
-  if (signal.reason instanceof Error) return signal.reason;
-  const error = new Error("Tileflow static map request was aborted");
-  error.name = "AbortError";
-  return error;
-}
-function assertStaticMapOperationIdentity(expected, actual) {
-  if (expected !== null && actual !== expected) {
-    throw new Error("Tileflow static map changed operation identity while polling");
-  }
-}
-function isSafeHttpUrl(value) {
-  try {
-    const url = new URL(value);
-    return ["http:", "https:"].includes(url.protocol) && !url.username && !url.password;
-  } catch {
-    return false;
-  }
-}
-function normalizeUrl(value) {
-  return value.replace(/\/+$/, "");
-}
+import {
+  createStaticMap,
+  createStaticMapIdempotencyKey,
+  precacheStaticMap,
+  prepareStaticMapRequest,
+  requestStaticMapUntilReady,
+  staticMapProcessingResultSchema,
+  staticMapReadyResultSchema,
+  validateStaticMapIdempotencyKey
+} from "./chunk-43QGLF6K.js";
+import {
+  createRenderManifest,
+  hashRenderManifest,
+  hashStaticSceneRequest,
+  staticRenderManifestSchema,
+  staticRendererSchemaVersion,
+  validateStaticRenderManifest
+} from "./chunk-HKYA7ZIU.js";
+import {
+  circle,
+  compileStaticOverlays,
+  line,
+  marker,
+  polygon
+} from "./chunk-LGEYA6FQ.js";
+import {
+  normalizeStaticScene,
+  validateStaticScene
+} from "./chunk-ROBEGDDY.js";
+import {
+  stableStringify,
+  staticOverlaySchema,
+  staticSceneLimits,
+  staticSceneSchema,
+  staticSceneSchemaVersion
+} from "./chunk-YUG3PBK2.js";
 export {
   circle,
   compileStaticOverlays,
@@ -576,6 +47,8 @@ export {
   normalizeStaticScene,
   polygon,
   precacheStaticMap,
+  prepareStaticMapRequest,
+  requestStaticMapUntilReady,
   stableStringify,
   staticMapProcessingResultSchema,
   staticMapReadyResultSchema,

package/dist/manifest.d.ts

@@ -0,0 +1,85 @@
+import { z } from 'zod';
+import { d as StaticSceneInput } from './scene-contract-DzsUeJ_V.js';
+
+declare const staticRendererSchemaVersion = 1;
+declare const staticRenderManifestSchema: z.ZodObject<{
+    mapId: z.ZodString;
+    rendererVersion: z.ZodString;
+    schemaVersion: z.ZodLiteral<1>;
+    scene: z.ZodObject<{
+        camera: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            bearing: z.ZodOptional<z.ZodNumber>;
+            center: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            type: z.ZodLiteral<"center">;
+            zoom: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            bearing: z.ZodOptional<z.ZodNumber>;
+            bounds: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            padding: z.ZodOptional<z.ZodNumber>;
+            type: z.ZodLiteral<"bounds">;
+        }, z.core.$strip>], "type">;
+        map: z.ZodString;
+        overlays: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            coordinates: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            id: z.ZodOptional<z.ZodString>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            type: z.ZodLiteral<"line">;
+            width: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>, z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            coordinate: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            id: z.ZodOptional<z.ZodString>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            radius: z.ZodDefault<z.ZodNumber>;
+            strokeColor: z.ZodOptional<z.ZodString>;
+            strokeWidth: z.ZodDefault<z.ZodNumber>;
+            type: z.ZodLiteral<"circle">;
+        }, z.core.$strip>, z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            coordinate: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+            id: z.ZodOptional<z.ZodString>;
+            radius: z.ZodDefault<z.ZodNumber>;
+            strokeColor: z.ZodDefault<z.ZodString>;
+            strokeWidth: z.ZodDefault<z.ZodNumber>;
+            type: z.ZodLiteral<"marker">;
+        }, z.core.$strip>, z.ZodObject<{
+            coordinates: z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+            fill: z.ZodDefault<z.ZodString>;
+            id: z.ZodOptional<z.ZodString>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            stroke: z.ZodOptional<z.ZodString>;
+            strokeWidth: z.ZodDefault<z.ZodNumber>;
+            type: z.ZodLiteral<"polygon">;
+        }, z.core.$strip>], "type">>>;
+        size: z.ZodObject<{
+            dpr: z.ZodOptional<z.ZodLiteral<1>>;
+            height: z.ZodNumber;
+            width: z.ZodNumber;
+        }, z.core.$strip>;
+        theme: z.ZodString;
+    }, z.core.$strip>;
+    styleId: z.ZodOptional<z.ZodString>;
+    styleRevision: z.ZodString;
+    styleUrl: z.ZodString;
+}, z.core.$strip>;
+type StaticRenderManifest = z.infer<typeof staticRenderManifestSchema>;
+declare function validateStaticRenderManifest(input: unknown): {
+    manifest: StaticRenderManifest;
+    ok: true;
+} | {
+    error: string;
+    ok: false;
+};
+declare function createRenderManifest(input: {
+    mapId: string;
+    rendererVersion: string;
+    scene: StaticSceneInput;
+    styleId?: string;
+    styleRevision: string;
+    styleUrl: string;
+}): StaticRenderManifest;
+declare function hashRenderManifest(manifest: StaticRenderManifest): Promise<string>;
+declare function hashStaticSceneRequest(scene: StaticSceneInput): Promise<string>;
+
+export { type StaticRenderManifest, createRenderManifest, hashRenderManifest, hashStaticSceneRequest, staticRenderManifestSchema, staticRendererSchemaVersion, validateStaticRenderManifest };