styled-map-package-api 5.0.0-pre.2 → 5.0.0-pre.4

package/dist/utils/file-formats.d.ts

@@ -1,8 +1,3 @@
-import { c as TileFormat } from '../types-qfyJk4ot.js';
-import '@maplibre/maplibre-gl-style-spec';
-import 'geojson';
-import 'type-fest';
-
 /**
  * For a given buffer, determine the tile format based on the magic bytes.
  * Will throw for unknown file types.
@@ -11,7 +6,7 @@ import 'type-fest';
  * @param {Buffer | Uint8Array} buf
  * @returns {import("../writer.js").TileFormat}
  */
-declare function getTileFormatFromBuffer(buf: Buffer | Uint8Array): TileFormat;
+export function getTileFormatFromBuffer(buf: Buffer | Uint8Array): import("../writer.js").TileFormat;
 /**
  * Determine the tile format from a readable stream from the magic bytes at the
  * start of the file. Used if data is served without a content-type header.
@@ -20,13 +15,11 @@ declare function getTileFormatFromBuffer(buf: Buffer | Uint8Array): TileFormat;
  * @param {ReadableStream<Uint8Array>} tileData Web ReadableStream
  * @returns {Promise<[import("../writer.js").TileFormat, ReadableStream<Uint8Array>]>}
  */
-declare function getTileFormatFromStream(tileData: ReadableStream<Uint8Array>): Promise<[TileFormat, ReadableStream<Uint8Array>]>;
+export function getTileFormatFromStream(tileData: ReadableStream<Uint8Array>): Promise<[import("../writer.js").TileFormat, ReadableStream<Uint8Array>]>;
 /**
  * Get the tile format from a MIME type. Throws for unsupported types.
  *
  * @param {string} mimeType
  * @returns {import("../writer.js").TileFormat}
  */
-declare function getFormatFromMimeType(mimeType: string): TileFormat;
-
-export { getFormatFromMimeType, getTileFormatFromBuffer, getTileFormatFromStream };
+export function getFormatFromMimeType(mimeType: string): import("../writer.js").TileFormat;

package/dist/utils/geo.d.ts

@@ -7,7 +7,7 @@
  * @param {{ x: number, y: number, z: number }} tile
  * @returns {BBox} Bounding Box [w, s, e, n]
  */
-declare function tileToBBox({ x, y, z }: {
+export function tileToBBox({ x, y, z }: {
     x: number;
     y: number;
     z: number;
@@ -15,7 +15,7 @@ declare function tileToBBox({ x, y, z }: {
 /**
  * @param {{ x: number, y: number, z: number }} tile
  */
-declare function getQuadkey({ x, y, z }: {
+export function getQuadkey({ x, y, z }: {
     x: number;
     y: number;
     z: number;
@@ -26,7 +26,7 @@ declare function getQuadkey({ x, y, z }: {
  * @param {string[]} urls
  * @param {{ x: number, y: number, z: number, scheme?: 'xyz' | 'tms' }} opts
  */
-declare function getTileUrl(urls: string[], { x, y, z, scheme }: {
+export function getTileUrl(urls: string[], { x, y, z, scheme }: {
     x: number;
     y: number;
     z: number;
@@ -35,12 +35,20 @@ declare function getTileUrl(urls: string[], { x, y, z, scheme }: {
 /**
  * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
  *
- * @param {[BBox, ...BBox[]]} bboxes
+ * @param {[Readonly<BBox>, ...Readonly<BBox>[]]} bboxes
  * @returns {BBox} Bounding Box [w, s, e, n]
  */
-declare function unionBBox(bboxes: [BBox, ...BBox[]]): BBox;
+export function unionBBox(bboxes: [Readonly<BBox>, ...Readonly<BBox>[]]): BBox;
+/**
+ * Convert a TMS Y coordinate to an XYZ Y coordinate.
+ *
+ * @param {{ y: number, z: number }} tile
+ * @returns {number} The XYZ Y coordinate
+ */
+export function tmsToXyzY({ y, z }: {
+    y: number;
+    z: number;
+}): number;
 /** Spherical Mercator max bounds, rounded to 6 decimal places */
-declare const MAX_BOUNDS: BBox;
-type BBox = [number, number, number, number];
-
-export { type BBox, MAX_BOUNDS, getQuadkey, getTileUrl, tileToBBox, unionBBox };
+export const MAX_BOUNDS: BBox;
+export type BBox = [number, number, number, number];

package/dist/utils/mapbox.d.ts

@@ -1,43 +1,41 @@
 /** @param {string} url */
-declare function isMapboxURL(url: string): boolean;
+export function isMapboxURL(url: string): boolean;
 /**
  * @param {string} url
  * @param {string} [accessToken]
  */
-declare function normalizeStyleURL(url: string, accessToken?: string): string;
+export function normalizeStyleURL(url: string, accessToken?: string): string;
 /**
  * @param {string} url
  * @param {string} [accessToken]
  */
-declare function normalizeGlyphsURL(url: string, accessToken?: string): string;
+export function normalizeGlyphsURL(url: string, accessToken?: string): string;
 /**
  * @param {string} url
  * @param {string} [accessToken]
  */
-declare function normalizeSourceURL(url: string, accessToken?: string): string;
+export function normalizeSourceURL(url: string, accessToken?: string): string;
 /**
  * @param {string} url
  * @param {'' | '@2x'} format
  * @param {'.png' | '.json'} extension
  * @param {string} [accessToken]
  */
-declare function normalizeSpriteURL(url: string, format: "" | "@2x", extension: ".png" | ".json", accessToken?: string): string;
+export function normalizeSpriteURL(url: string, format: "" | "@2x", extension: ".png" | ".json", accessToken?: string): string;
 /**
  * @param {any} tileURL
  * @param {string} sourceURL
  * @param {256 | 512} [tileSize]
  * @param {{ devicePixelRatio?: number; supportsWebp?: boolean; }} [opts]
  */
-declare function normalizeTileURL(tileURL: any, sourceURL: string, tileSize?: 256 | 512, { devicePixelRatio, supportsWebp }?: {
+export function normalizeTileURL(tileURL: any, sourceURL: string, tileSize?: 256 | 512, { devicePixelRatio, supportsWebp }?: {
     devicePixelRatio?: number;
     supportsWebp?: boolean;
 }): any;
-declare const API_URL: "https://api.mapbox.com";
-type URLObject = {
+export const API_URL: "https://api.mapbox.com";
+export type URLObject = {
     protocol: string;
     authority: string;
     path: string;
     params: string[];
 };
-
-export { API_URL, type URLObject, isMapboxURL, normalizeGlyphsURL, normalizeSourceURL, normalizeSpriteURL, normalizeStyleURL, normalizeTileURL };

package/dist/utils/misc.d.ts

@@ -7,8 +7,8 @@
  * @param {T} obj
  * @returns {T}
  */
-declare function clone<T>(obj: T): T;
-declare function noop(): void;
+export function clone<T>(obj: T): T;
+export function noop(): void;
 /**
  * Like `Object.hasOwn`, but refines the type of `key`.
  *
@@ -17,6 +17,4 @@ declare function noop(): void;
  * @param {string} key
  * @returns {key is (keyof T)}
  */
-declare function hasOwn<T extends Record<string, unknown>>(obj: T, key: string): key is (keyof T);
-
-export { clone, hasOwn, noop };
+export function hasOwn<T extends Record<string, unknown>>(obj: T, key: string): key is (keyof T);

package/dist/utils/streams.d.ts

@@ -1,5 +1,3 @@
-import * as stream_web from 'stream/web';
-
 /**
  * Create a ReadableStream from an async iterable. Uses the native
  * `ReadableStream.from()` when available (Node 20+), otherwise falls back to a
@@ -9,7 +7,7 @@ import * as stream_web from 'stream/web';
  * @param {AsyncIterable<T>} iterable
  * @returns {ReadableStream<T>}
  */
-declare function readableFromAsync<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
+export function readableFromAsync<T>(iterable: AsyncIterable<T>): ReadableStream<T>;
 /**
  * Create a writable stream from an async function. Default concurrency is 16 -
  * this is the number of parallel functions that will be pending before
@@ -19,7 +17,7 @@ declare function readableFromAsync<T>(iterable: AsyncIterable<T>): ReadableStrea
  * @param {T} fn
  * @returns {WritableStream}
  */
-declare function writeStreamFromAsync<T extends (...args: any[]) => Promise<void>>(fn: T, { concurrency }?: {
+export function writeStreamFromAsync<T extends (...args: any[]) => Promise<void>>(fn: T, { concurrency }?: {
     concurrency?: number | undefined;
 }): WritableStream;
 /** @typedef {(opts: { totalBytes: number, chunkBytes: number }) => void} ProgressCallback */
@@ -28,22 +26,20 @@ declare function writeStreamFromAsync<T extends (...args: any[]) => Promise<void
  * optional `onprogress` callback that will be called with the accumulated
  * total byte count and the chunk byte count after each chunk.
  */
-declare class ProgressStream {
+export class ProgressStream {
     /**
      * @param {{ onprogress?: ProgressCallback }} [opts]
      */
     constructor({ onprogress }?: {
         onprogress?: ProgressCallback;
     });
-    get readable(): stream_web.ReadableStream<any>;
-    get writable(): stream_web.WritableStream<any>;
+    get readable(): ReadableStream<any>;
+    get writable(): WritableStream<any>;
     /** Total bytes that have passed through this stream */
     get byteLength(): number;
     #private;
 }
-type ProgressCallback = (opts: {
+export type ProgressCallback = (opts: {
     totalBytes: number;
     chunkBytes: number;
 }) => void;
-
-export { type ProgressCallback, ProgressStream, readableFromAsync, writeStreamFromAsync };

package/dist/utils/style.d.ts

@@ -1,10 +1,3 @@
-import { BBox } from './geo.js';
-import { I as InlinedSource } from '../types-qfyJk4ot.js';
-import * as _maplibre_maplibre_gl_style_spec from '@maplibre/maplibre-gl-style-spec';
-import { StyleSpecification, ValidationError } from '@maplibre/maplibre-gl-style-spec';
-import 'geojson';
-import 'type-fest';
-
 /** @import {StyleSpecification, ExpressionSpecification, ValidationError} from '@maplibre/maplibre-gl-style-spec' */
 /**
  * For a given style, replace all font stacks (`text-field` properties) with the
@@ -16,7 +9,7 @@ import 'type-fest';
  * @param {StyleSpecification} style
  * @param {string[]} fonts
  */
-declare function replaceFontStacks(style: StyleSpecification, fonts: string[]): StyleSpecification;
+export function replaceFontStacks(style: StyleSpecification, fonts: string[]): StyleSpecification;
 /**
  * From given style layers, create a new style by calling the provided callback
  * function on every font stack defined in the style.
@@ -25,7 +18,14 @@ declare function replaceFontStacks(style: StyleSpecification, fonts: string[]):
  * @param {(fontStack: string[]) => string[]} callbackFn
  * @returns {StyleSpecification['layers']}
  */
-declare function mapFontStacks(layers: StyleSpecification["layers"], callbackFn: (fontStack: string[]) => string[]): StyleSpecification["layers"];
+export function mapFontStacks(layers: StyleSpecification["layers"], callbackFn: (fontStack: string[]) => string[]): StyleSpecification["layers"];
+/**
+ * Check whether a PBF glyph range (identified by its start codepoint) is
+ * rendered client-side by MapLibre GL and does not need a server-side PBF file.
+ * @param {number} rangeStart
+ * @returns {boolean}
+ */
+export function isLocallyRenderedRange(rangeStart: number): boolean;
 /**
  * @typedef {object} TileJSONPartial
  * @property {string[]} tiles
@@ -41,26 +41,37 @@ declare function mapFontStacks(layers: StyleSpecification["layers"], callbackFn:
  * @param {unknown} tilejson
  * @returns {asserts tilejson is TileJSONPartial}
  */
-declare function assertTileJSON(tilejson: unknown): asserts tilejson is TileJSONPartial;
+export function assertTileJSON(tilejson: unknown): asserts tilejson is TileJSONPartial;
 /**
  * Check whether a source is already inlined (e.g. does not reference a TileJSON or GeoJSON url)
  *
  * @param {import('@maplibre/maplibre-gl-style-spec').SourceSpecification} source
  * @returns {source is import('../types.js').InlinedSource}
  */
-declare function isInlinedSource(source: _maplibre_maplibre_gl_style_spec.SourceSpecification): source is InlinedSource;
-declare const validateStyle: {
+export function isInlinedSource(source: import("@maplibre/maplibre-gl-style-spec").SourceSpecification): source is import("../types.js").InlinedSource;
+/**
+ * PBF glyph ranges rendered client-side by MapLibre GL via
+ * `localIdeographFontFamily` (enabled by default as 'sans-serif'). SMP files
+ * do not need to include glyph data for these ranges. Each entry is a
+ * half-open interval [start, end) of PBF range start codepoints.
+ *
+ * Based on `codePointUsesLocalIdeographFontFamily()` in MapLibre GL JS.
+ * Only ranges where the ENTIRE 256-codepoint PBF range is locally rendered
+ * are listed here; partially-local ranges are conservatively kept as required.
+ */
+export const LOCAL_GLYPH_RANGES: number[][];
+export const validateStyle: {
     (style: unknown): style is StyleSpecification;
     errors: ValidationError[];
 };
-type TileJSONPartial = {
+export type TileJSONPartial = {
     tiles: string[];
     description?: string | undefined;
     attribution?: string | undefined;
     vector_layers?: object[] | undefined;
-    bounds?: BBox | undefined;
+    bounds?: import("./geo.js").BBox | undefined;
     maxzoom?: number | undefined;
     minzoom?: number | undefined;
 };
-
-export { type TileJSONPartial, assertTileJSON, isInlinedSource, mapFontStacks, replaceFontStacks, validateStyle };
+import type { StyleSpecification } from '@maplibre/maplibre-gl-style-spec';
+import type { ValidationError } from '@maplibre/maplibre-gl-style-spec';

package/dist/utils/templates.d.ts

@@ -1,32 +1,27 @@
-import * as type_fest from 'type-fest';
-import { d as GlyphRange, T as TileInfo, c as TileFormat } from '../types-qfyJk4ot.js';
-import '@maplibre/maplibre-gl-style-spec';
-import 'geojson';
-
 /**
  * @param {string} path
  * @returns
  */
-declare function getResourceType(path: string): "sprite" | "style" | "tile" | "glyph";
+export function getResourceType(path: string): "sprite" | "tile" | "glyph" | "style";
 /**
  * Determine the content type of a file based on its extension.
  *
  * @param {string} path
  */
-declare function getContentType(path: string): "application/json; charset=utf-8" | "application/x-protobuf" | "image/png" | "image/jpeg" | "image/webp" | "application/vnd.mapbox-vector-tile";
+export function getContentType(path: string): "application/json; charset=utf-8" | "application/x-protobuf" | "image/png" | "image/jpeg" | "image/webp" | "application/vnd.mapbox-vector-tile";
 /**
  * Get the filename for a tile, given the TileInfo
  *
  * @param {import("type-fest").SetRequired<import("../writer.js").TileInfo, 'format'>} tileInfo
  * @returns
  */
-declare function getTileFilename({ sourceId, z, x, y, format }: type_fest.SetRequired<TileInfo, "format">): string;
+export function getTileFilename({ sourceId, z, x, y, format }: import("type-fest").SetRequired<import("../writer.js").TileInfo, "format">): string;
 /**
  * Get a filename for a sprite file, given the sprite id, pixel ratio and extension
  *
  * @param {{ id: string, pixelRatio: number, ext: '.json' | '.png'}} spriteInfo
  */
-declare function getSpriteFilename({ id, pixelRatio, ext }: {
+export function getSpriteFilename({ id, pixelRatio, ext }: {
     id: string;
     pixelRatio: number;
     ext: ".json" | ".png";
@@ -38,14 +33,14 @@ declare function getSpriteFilename({ id, pixelRatio, ext }: {
  * @param {string} options.fontstack
  * @param {import("../writer.js").GlyphRange} options.range
  */
-declare function getGlyphFilename({ fontstack, range }: {
+export function getGlyphFilename({ fontstack, range }: {
     fontstack: string;
-    range: GlyphRange;
+    range: import("../writer.js").GlyphRange;
 }): string;
 /**
  * Get the URI template for the sprites in the style
  */
-declare function getSpriteUri(id?: string): string;
+export function getSpriteUri(id?: string): string;
 /**
  * Get the URI template for tiles in the style
  *
@@ -54,9 +49,9 @@ declare function getSpriteUri(id?: string): string;
  * @param {import("../writer.js").TileFormat} opts.format
  * @returns
  */
-declare function getTileUri({ sourceId, format }: {
+export function getTileUri({ sourceId, format }: {
     sourceId: string;
-    format: TileFormat;
+    format: import("../writer.js").TileFormat;
 }): string;
 /**
  * Replaces variables in a string with values provided in an object. Variables
@@ -66,14 +61,24 @@ declare function getTileUri({ sourceId, format }: {
  * @param {Record<string, string | number>} variables - An object where the keys correspond to variable names and values correspond to the replacement values.
  * @returns {string} The string with the variables replaced by their corresponding values.
  */
-declare function replaceVariables(template: string, variables: Record<string, string | number>): string;
-declare const URI_SCHEME: "smp";
-declare const URI_BASE: string;
-declare const VERSION_FILE: "VERSION";
-declare const FORMAT_VERSION: "1.0";
-declare const STYLE_FILE: "style.json";
-declare const SOURCES_FOLDER: "s";
-declare const FONTS_FOLDER: "fonts";
-declare const GLYPH_URI: string;
-
-export { FONTS_FOLDER, FORMAT_VERSION, GLYPH_URI, SOURCES_FOLDER, STYLE_FILE, URI_BASE, URI_SCHEME, VERSION_FILE, getContentType, getGlyphFilename, getResourceType, getSpriteFilename, getSpriteUri, getTileFilename, getTileUri, replaceVariables };
+export function replaceVariables(template: string, variables: Record<string, string | number>): string;
+/**
+ * Inverse of {@link replaceVariables}. Converts a template string into a RegExp
+ * that captures the placeholder values. Only placeholders present in the
+ * `placeholders` map become named capture groups; unknown placeholders are
+ * treated as literal text and escaped.
+ *
+ * @param {string} template - The template string with `{name}` placeholders.
+ * @param {Record<string, string>} placeholders - Map of placeholder
+ *   name → regex pattern (e.g. `{ z: '\\d+' }`).
+ * @returns {RegExp} A RegExp with named capture groups for each known placeholder.
+ */
+export function templateToRegex(template: string, placeholders: Record<string, string>): RegExp;
+export const URI_SCHEME: "smp";
+export const URI_BASE: string;
+export const VERSION_FILE: "VERSION";
+export const FORMAT_VERSION: "1.0";
+export const STYLE_FILE: "style.json";
+export const SOURCES_FOLDER: "s";
+export const FONTS_FOLDER: "fonts";
+export const GLYPH_URI: string;

package/dist/validator.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Validate a Styled Map Package file against the SMP specification.
+ *
+ * Returns a list of issues, each with a `kind` ('error' or 'warning'), a
+ * `severity` ('fatal', 'rendering', or 'spec'), and a stable `type` string
+ * for programmatic filtering. Use `result.valid` to check spec compliance
+ * and `result.usable` to check whether the file can be opened by the reader.
+ *
+ * @param {string | import('@gmaclennan/zip-reader').ZipReader} source Path to the .smp file, or a ZipReader instance
+ * @param {ValidateOptions} [options]
+ * @returns {Promise<ValidationResult>}
+ */
+export function validate(source: string | import("@gmaclennan/zip-reader").ZipReader, options?: ValidateOptions): Promise<ValidationResult>;
+export type IssueFn = ReturnType<typeof createIssue>;
+export type ValidationIssue = {
+    /**
+     * - error = spec MUST violation; warning = SHOULD/RECOMMENDED
+     */
+    kind: "error" | "warning";
+    /**
+     * - Practical impact:
+     * fatal = reader will fail to open; rendering = map renders with visible
+     * issues; spec = non-compliance that doesn't affect practical use
+     */
+    severity: "fatal" | "rendering" | "spec";
+    /**
+     * - Stable identifier for programmatic matching
+     */
+    type: string;
+    /**
+     * - Human-readable description
+     */
+    message: string;
+    /**
+     * - Location context (e.g. 'sources.test.tiles', 'VERSION')
+     */
+    path?: string | undefined;
+};
+export type ValidationResult = {
+    /**
+     * - true when there are no errors (warnings are acceptable)
+     */
+    valid: boolean;
+    /**
+     * - true when there are no fatal issues (the file can be opened)
+     */
+    usable: boolean;
+    /**
+     * - all issues found
+     */
+    issues: ValidationIssue[];
+};
+export type ValidateOptions = {
+    /**
+     * Maximum number of ZIP entries to
+     * process before aborting. Default matches the Reader default (~a global z9
+     * tileset).
+     */
+    maxEntries?: number | undefined;
+};
+/**
+ * @param {ValidationIssue[]} issues
+ * @param {'error' | 'warning'} kind
+ */
+declare function createIssue(issues: ValidationIssue[], kind: "error" | "warning"): (type: string, message: string, path?: string) => number;
+export {};

package/dist/writer.d.ts

@@ -1,4 +1,157 @@
-export { G as GlyphInfo, d as GlyphRange, e as SUPPORTED_SOURCE_TYPES, f as Source, g as SourceInfo, c as TileFormat, T as TileInfo, W as Writer, h as WriterOptions } from './types-qfyJk4ot.js';
-import '@maplibre/maplibre-gl-style-spec';
-import 'geojson';
-import 'type-fest';
+/** @typedef {string | Uint8Array | ReadableStream } Source */
+/** @typedef {`${number}-${number}`} GlyphRange */
+/** @typedef {'png' | 'mvt' | 'jpg' | 'webp'} TileFormat */
+/**
+ * @typedef {object} SourceInfo
+ * @property {import('./types.js').SMPSource} source
+ * @property {string} encodedSourceId
+ * @property {TileFormat} [format]
+ */
+/**
+ * @typedef {object} TileInfo
+ * @property {number} z Zoom level
+ * @property {number} x Tile column (XYZ scheme)
+ * @property {number} y Tile row (XYZ scheme, origin at top-left). If your source uses TMS, convert with {@link import('./utils/geo.js').tmsToXyzY} before passing.
+ * @property {string} sourceId
+ * @property {TileFormat} [format]
+ */
+/**
+ * @typedef {object} GlyphInfo
+ * @property {string} font
+ * @property {GlyphRange} range
+ */
+/** @import { StyleSpecification } from '@maplibre/maplibre-gl-style-spec' */
+/** @import { InputSource, SMPSource } from './types.js' */
+export const SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
+/**
+ * @typedef {object} WriterOptions
+ * @property {boolean} [dedupe] When true, duplicate tiles (with identical
+ *   content) are stored only once in the archive. Additional entries in the
+ *   central directory point to the same data. This reduces file size for
+ *   tilesets with many repeated tiles (e.g. ocean tiles).
+ */
+/**
+ * Write a styled map package to a stream. Stream `writer.outputStream` to a
+ * destination, e.g. `fs.createWriteStream('my-map.styledmap')`. You must call
+ * `witer.finish()` and then wait for your writable stream to `finish` before
+ * using the output.
+ */
+export class Writer {
+    static SUPPORTED_SOURCE_TYPES: readonly ["raster", "vector", "geojson"];
+    /**
+     * @param {any} style A v7 or v8 MapLibre style. v7 styles will be migrated to
+     * v8. (There are currently no typescript declarations for v7 styles, hence
+     * this is typed as `any` and validated internally)
+     * @param {WriterOptions} [options]
+     */
+    constructor(style: any, { dedupe }?: WriterOptions);
+    /**
+     * @returns {ReadableStream<Uint8Array>} Readable stream of the styled map package
+     */
+    get outputStream(): ReadableStream<Uint8Array>;
+    /**
+     * Abort the output stream with an error. Call this if an error occurs during
+     * writing to propagate the error to consumers of `outputStream`.
+     *
+     * @param {Error} reason
+     */
+    abort(reason: Error): void;
+    /**
+     * Add a tile to the styled map package. Coordinates must use the XYZ scheme
+     * (origin at top-left / north-west). If your tiles use TMS coordinates,
+     * convert the Y value first with `tmsToXyzY({ y, z })` from `utils/geo.js`.
+     *
+     * @param {Source} tileData
+     * @param {TileInfo} opts
+     */
+    addTile(tileData: Source, { z, x, y, sourceId, format }: TileInfo): Promise<void>;
+    /**
+     * Create a write stream for adding tiles to the styled map package
+     *
+     * @param {object} opts
+     * @param {number} [opts.concurrency=16] The number of concurrent writes
+     *
+     * @returns
+     */
+    createTileWriteStream({ concurrency }?: {
+        concurrency?: number | undefined;
+    }): WritableStream<any>;
+    /**
+     * Add a sprite to the styled map package
+     *
+     * @param {object} options
+     * @param {Source} options.json
+     * @param {Source} options.png
+     * @param {number} [options.pixelRatio]
+     * @param {string} [options.id='default']
+     * @returns {Promise<void>}
+     */
+    addSprite({ json, png, pixelRatio, id }: {
+        json: Source;
+        png: Source;
+        pixelRatio?: number | undefined;
+        id?: string | undefined;
+    }): Promise<void>;
+    /**
+     * Add glyphs to the styled map package
+     *
+     * @param {Source} glyphData
+     * @param {GlyphInfo} glyphInfo
+     * @returns {Promise<void>}
+     */
+    addGlyphs(glyphData: Source, { font: fontName, range }: GlyphInfo): Promise<void>;
+    /**
+     * Create a write stream for adding glyphs to the styled map package
+     *
+     * @param {object} opts
+     * @param {number} [opts.concurrency=16] The number of concurrent writes
+     * @returns
+     */
+    createGlyphWriteStream({ concurrency }?: {
+        concurrency?: number | undefined;
+    }): WritableStream<any>;
+    /**
+     * Finalize the styled map package and write the style to the archive.
+     * This method must be called to complete the archive.
+     * You must wait for your destination write stream to 'finish' before using the output.
+     */
+    finish(): Promise<void>;
+    #private;
+}
+export type Source = string | Uint8Array | ReadableStream;
+export type GlyphRange = `${number}-${number}`;
+export type TileFormat = "png" | "mvt" | "jpg" | "webp";
+export type SourceInfo = {
+    source: import("./types.js").SMPSource;
+    encodedSourceId: string;
+    format?: TileFormat | undefined;
+};
+export type TileInfo = {
+    /**
+     * Zoom level
+     */
+    z: number;
+    /**
+     * Tile column (XYZ scheme)
+     */
+    x: number;
+    /**
+     * Tile row (XYZ scheme, origin at top-left). If your source uses TMS, convert with {@link import ('./utils/geo.js').tmsToXyzY} before passing.
+     */
+    y: number;
+    sourceId: string;
+    format?: TileFormat | undefined;
+};
+export type GlyphInfo = {
+    font: string;
+    range: GlyphRange;
+};
+export type WriterOptions = {
+    /**
+     * When true, duplicate tiles (with identical
+     * content) are stored only once in the archive. Additional entries in the
+     * central directory point to the same data. This reduces file size for
+     * tilesets with many repeated tiles (e.g. ocean tiles).
+     */
+    dedupe?: boolean | undefined;
+};