map-gl-offline 0.6.0 → 0.7.0

package/dist/index.umd.js

@@ -29,7 +29,7 @@
      */
     // IndexedDB Configuration
     const DB_NAME = 'offline-map-db';
-    const DB_VERSION = 3;
+    const DB_VERSION = 4;
     // Store Names (regions are stored inside styles.regions[], not as a separate store)
     const STORE_NAMES = {
         TILES: 'tiles',
@@ -37,6 +37,7 @@
         SPRITES: 'sprites',
         GLYPHS: 'glyphs',
         FONTS: 'fonts',
+        MODELS: 'models',
     };
     // Download Configuration
     const DOWNLOAD_DEFAULTS = {
@@ -244,7 +245,7 @@
      * Called during initial database creation or when stores are missing.
      */
     function createStores(db) {
-        const stores = ['regions', 'tiles', 'styles', 'sprites', 'glyphs', 'fonts'];
+        const stores = ['regions', 'tiles', 'styles', 'sprites', 'glyphs', 'fonts', 'models'];
         for (const storeName of stores) {
             if (!db.objectStoreNames.contains(storeName)) {
                 db.createObjectStore(storeName, { keyPath: 'key' });
@@ -326,6 +327,7 @@
      * - sprites: Sprite images and JSON
      * - glyphs: Font glyph data
      * - fonts: Font files
+     * - models: 3D model files (.glb) for Mapbox Standard tree/turbine layers
      * - regions: (deprecated) Legacy region storage, migrated to styles.regions[]
      *
      * @example
@@ -345,6 +347,9 @@
                     if (oldVersion > 0 && oldVersion < 3) {
                         migrateRegionsToStyles(transaction);
                     }
+                    // Migration: v3 -> v4
+                    // Adds the `models` store for Mapbox Standard 3D model assets.
+                    // No data migration needed — createStores above handles it.
                 },
             });
         }
@@ -1201,6 +1206,7 @@
     // idb://{downloadId}/tile/{sourceKey}/{url}
     // idb://{downloadId}/glyph/{fontstack}/{range}.pbf
     // idb://{downloadId}/sprite/{spriteName}
+    // idb://{styleId}/model/{modelName}
     // idb://{downloadId}/tilesjson/{url}
     // Cache for region ID to style mapping to avoid repeated DB queries
     const regionToStyleCache = new Map();
@@ -1572,6 +1578,33 @@
                     }
                     break;
                 }
+                case 'model': {
+                    // Model URLs are rewritten by patchStyleForOffline to:
+                    //   idb://{styleId}/model/{modelName}
+                    // Models are keyed by {styleId}::model::{modelName} in the store.
+                    // Mirror the sprite resolution fallback: try the style ID first,
+                    // then the download/region ID (in case the request came through a
+                    // region-scoped URL).
+                    const styleEntry = await findStyleByRegionId(db, downloadId);
+                    const actualStyleId = styleEntry?.key || downloadId;
+                    const candidates = Array.from(new Set([
+                        `${actualStyleId}::model::${decodedResourcePath}`,
+                        `${downloadId}::model::${decodedResourcePath}`,
+                    ]));
+                    idbLogger.debug(`Model candidates for "${decodedResourcePath}":`, candidates);
+                    for (const candidateKey of candidates) {
+                        const resource = await db.get('models', candidateKey);
+                        if (resource?.data) {
+                            idbLogger.debug(`Found model using key: ${candidateKey}`);
+                            return new Response(resource.data, {
+                                status: 200,
+                                headers: { 'Content-Type': resource.contentType || 'model/gltf-binary' },
+                            });
+                        }
+                    }
+                    idbLogger.warn(`Model not found, tried keys: ${candidates.join(', ')}`);
+                    break;
+                }
                 case 'tilesjson': {
                     idbLogger.debug(`Looking for tilejson with downloadId: ${downloadId}, resourcePath: ${decodedResourcePath}`);
                     // First try direct lookup (for style-level downloads)
@@ -2027,14 +2060,29 @@
                 });
             }
         }
-        // Patch top-level models (Mapbox Standard 3D landmarks)
+        // Patch top-level models (Mapbox Standard 3D trees / wind turbines).
+        // Two shapes exist in the wild:
+        //   - Mapbox Standard: `{ "maple1-lod1": "mapbox://models/mapbox/maple1-v4-lod1.glb" }` (string values)
+        //   - Older/generic:   `{ "name": { "uri": "mapbox://..." } }`               (object values)
+        // Models are keyed on the style ID (like sprites) so they can be shared
+        // across regions.
         if (style.models) {
-            for (const [modelId, modelConfig] of Object.entries(style.models)) {
-                if (modelConfig.uri) {
-                    modelConfig.uri = `idb://${downloadId}/model/${modelId}`;
+            const modelBaseId = styleId || downloadId;
+            const models = style.models;
+            let patchedCount = 0;
+            for (const [modelId, value] of Object.entries(models)) {
+                if (typeof value === 'string') {
+                    models[modelId] = `idb://${modelBaseId}/model/${modelId}`;
+                    patchedCount++;
+                }
+                else if (value && typeof value === 'object' && 'uri' in value && value.uri) {
+                    value.uri = `idb://${modelBaseId}/model/${modelId}`;
+                    patchedCount++;
                 }
             }
-            styleLogger.debug(`Patched ${Object.keys(style.models).length} model URIs`);
+            if (patchedCount > 0) {
+                styleLogger.debug(`Patched ${patchedCount} model URIs (styleId: ${modelBaseId})`);
+            }
         }
         styleLogger.debug(`Final patched style:`, style);
         return style;
@@ -2602,12 +2650,22 @@
                 });
             }
         }
-        // Convert models
+        // Convert models. Two shapes in the wild:
+        //   - Mapbox Standard: `{ name: "idb://..." }` (string value)
+        //   - Older/generic:   `{ name: { uri: "idb://..." } }` (object value)
         if (converted.models) {
-            for (const modelKey of Object.keys(converted.models)) {
-                const model = converted.models[modelKey];
-                if (model.uri && typeof model.uri === 'string' && model.uri.startsWith('idb://')) {
-                    model.uri = replace(model.uri);
+            const models = converted.models;
+            for (const modelKey of Object.keys(models)) {
+                const value = models[modelKey];
+                if (typeof value === 'string') {
+                    if (value.startsWith('idb://')) {
+                        models[modelKey] = replace(value);
+                    }
+                }
+                else if (value && typeof value === 'object') {
+                    if (typeof value.uri === 'string' && value.uri.startsWith('idb://')) {
+                        value.uri = replace(value.uri);
+                    }
                 }
             }
         }
@@ -4928,7 +4986,15 @@
                     deletedSprites++;
                 }
             }
-            regionLogger$1.info(`Deleted style resources: ${deletedFonts} fonts, ${deletedGlyphs} glyphs, ${deletedSprites} sprites`);
+            let deletedModels = 0;
+            const modelTx = db.transaction('models', 'readwrite');
+            for await (const cursor of modelTx.store) {
+                if (resourceKeyBelongsToStyle(cursor.value.key, styleId)) {
+                    await cursor.delete();
+                    deletedModels++;
+                }
+            }
+            regionLogger$1.info(`Deleted style resources: ${deletedFonts} fonts, ${deletedGlyphs} glyphs, ${deletedSprites} sprites, ${deletedModels} models`);
         }
         /**
          * Delete all tiles for a style
@@ -5036,7 +5102,7 @@
             if (!region.styleUrl) {
                 throw new Error('Region must have a styleUrl');
             }
-            const { onProgress, provider = 'auto', accessToken, skipGlyphs = false, skipSprites = false, glyphRanges, tileOptions, } = options;
+            const { onProgress, provider = 'auto', accessToken, skipGlyphs = false, skipSprites = false, skipModels = false, glyphRanges, tileOptions, } = options;
             const emit = (phase, completed, total, message) => {
                 if (!onProgress)
                     return;
@@ -5091,8 +5157,13 @@
                 const spriteSources = normalizeSpriteProperty(originalSpriteUrl);
                 if (spriteSources.length > 0) {
                     const { downloadSprites } = await Promise.resolve().then(function () { return spriteService$1; });
-                    const suffixes = ['.json', '.png', '@2x.json', '@2x.png'];
-                    const totalFiles = spriteSources.length * suffixes.length;
+                    // Standard four sprite variants. For Mapbox Standard, an `iconset.pbf`
+                    // sibling is also served under the same /styles/v1/.../<hash>/ path
+                    // — we detect that case per-source below and append it to the list.
+                    const baseSuffixes = ['.json', '.png', '@2x.json', '@2x.png'];
+                    // Estimate total files assuming iconset is always included (the actual
+                    // number may be smaller; the emit helper clamps progress to total).
+                    const totalFiles = spriteSources.length * (baseSuffixes.length + 1);
                     let completed = 0;
                     emit('sprites', 0, totalFiles, 'Downloading sprites');
                     for (const source of spriteSources) {
@@ -5101,9 +5172,27 @@
                             spriteBase = resolveMapboxUrl(spriteBase, effectiveAccessToken);
                         }
                         const qIndex = spriteBase.indexOf('?');
-                        const spriteUrls = suffixes.map(suffix => qIndex !== -1
-                            ? spriteBase.slice(0, qIndex) + suffix + spriteBase.slice(qIndex)
-                            : spriteBase + suffix);
+                        const suffixes = [...baseSuffixes];
+                        // Mapbox Standard serves an iconset.pbf alongside the sprite under
+                        // /styles/v1/{owner}/{style}/{hash}/sprite → the sibling file is
+                        // /styles/v1/{owner}/{style}/{hash}/iconset.pbf. The last path
+                        // segment is `sprite`, so replacing it with `iconset.pbf` works.
+                        const pathWithoutQuery = qIndex !== -1 ? spriteBase.slice(0, qIndex) : spriteBase;
+                        const isMapboxStandardSprite = /api\.mapbox\.com\/styles\/v1\/.+\/sprite$/.test(pathWithoutQuery);
+                        if (isMapboxStandardSprite) {
+                            // The path-rewrite suffix replaces the trailing `sprite` segment.
+                            suffixes.push('__ICONSET__');
+                        }
+                        const spriteUrls = suffixes.map(suffix => {
+                            if (suffix === '__ICONSET__') {
+                                // Replace trailing `sprite` with `iconset.pbf`, preserving query.
+                                const base = pathWithoutQuery.replace(/sprite$/, 'iconset.pbf');
+                                return qIndex !== -1 ? base + spriteBase.slice(qIndex) : base;
+                            }
+                            return qIndex !== -1
+                                ? spriteBase.slice(0, qIndex) + suffix + spriteBase.slice(qIndex)
+                                : spriteBase + suffix;
+                        });
                         try {
                             const result = await downloadSprites(spriteUrls, styleId, {
                                 enableValidation: true,
@@ -5149,7 +5238,42 @@
                     }
                 }
             }
-            // 4. Tiles — use the stored (source-embedded) style, which still has HTTP tile URLs
+            // 4. Models — Mapbox Standard's `style.models` references 3D tree /
+            //    turbine .glb assets. Two value shapes exist in the wild
+            //    (plain string or `{ uri }`) — we accept both.
+            let modelResult;
+            if (!skipModels && storedStyle.models) {
+                const rawModels = storedStyle.models;
+                const resolved = {};
+                for (const [name, value] of Object.entries(rawModels)) {
+                    const uri = typeof value === 'string' ? value : value?.uri;
+                    if (!uri)
+                        continue;
+                    if (uri.startsWith('idb://'))
+                        continue; // already patched
+                    const httpUrl = isMapboxProtocol(uri) && effectiveAccessToken
+                        ? resolveMapboxUrl(uri, effectiveAccessToken)
+                        : uri;
+                    if (httpUrl.startsWith('http://') || httpUrl.startsWith('https://')) {
+                        resolved[name] = httpUrl;
+                    }
+                }
+                if (Object.keys(resolved).length > 0) {
+                    const { downloadModels } = await Promise.resolve().then(function () { return modelService$1; });
+                    emit('models', 0, Object.keys(resolved).length, 'Downloading 3D models');
+                    try {
+                        modelResult = await downloadModels(resolved, styleId, {
+                            onProgress: (progress) => {
+                                emit('models', progress.completed, progress.total, 'Downloading 3D models');
+                            },
+                        });
+                    }
+                    catch (error) {
+                        regionLogger$1.warn('Model download failed (non-fatal):', error);
+                    }
+                }
+            }
+            // 5. Tiles — use the stored (source-embedded) style, which still has HTTP tile URLs
             const { downloadTiles } = await Promise.resolve().then(function () { return tileService$1; });
             const regionForTiles = { ...region, styleId };
             emit('tiles', 0, 100, 'Downloading tiles');
@@ -5162,7 +5286,7 @@
                     tileOptions?.onProgress?.(progress);
                 },
             });
-            // 5. Metadata — must run last, since addRegion patches style URLs to idb://.
+            // 6. Metadata — must run last, since addRegion patches style URLs to idb://.
             // Do NOT auto-fill tileExtension from tileResult: that's only the first
             // source's extension, and addRegion feeds it to patchStyleForOffline which
             // would override ALL sources — breaking mixed raster+vector styles. The
@@ -5178,6 +5302,7 @@
                 styleResult,
                 spriteResults,
                 glyphResult,
+                modelResult,
                 tileResult,
             };
         }
@@ -6316,10 +6441,15 @@
                     tilesLength: config.tiles ? config.tiles.length : 0,
                     url: config.url,
                 });
-                // Handle tile-based sources (vector, raster, raster-dem, batched-model)
+                // Handle tile-based sources (vector, raster, raster-dem, batched-model,
+                // raster-array). `raster-array` is used by Mapbox Standard for layers
+                // like `mapbox-landmarks` (mapbox.mapbox-landmark-icons-v1) — the tiles
+                // are fetched from the same /v4/ endpoint as other tilesets, so the
+                // TileJSON resolution path below handles them uniformly.
                 if (config.type === 'vector' ||
                     config.type === 'raster' ||
                     config.type === 'raster-dem' ||
+                    config.type === 'raster-array' ||
                     config.type === 'batched-model') {
                     // Handle direct tile URLs in the source config
                     if (config.tiles && Array.isArray(config.tiles) && config.tiles.length > 0) {
@@ -7052,6 +7182,201 @@
         verifyAndRepairGlyphs: verifyAndRepairGlyphs
     });
 
+    const modelLogger = logger.scope('ModelService');
+    /**
+     * Build the storage key for a model. Kept consistent with sprite/glyph
+     * conventions: `{styleId}::model::{modelName}`.
+     */
+    function modelKey(styleId, modelName) {
+        return `${styleId}::model::${modelName}`;
+    }
+    /** True when the given key belongs to the given styleId's model store prefix. */
+    function modelKeyBelongsToStyle(key, styleId) {
+        return key.startsWith(`${styleId}::model::`);
+    }
+    /**
+     * Service for downloading, storing, and serving Mapbox 3D model (.glb) files.
+     *
+     * Mapbox Standard declares 32 models at the top of `style.models`:
+     *
+     * ```json
+     * {
+     *   "maple1-lod1": "mapbox://models/mapbox/maple1-v4-lod1.glb",
+     *   ...
+     * }
+     * ```
+     *
+     * `model` layers (e.g. `trees`, `wind-turbine-towers`) pick one by name at
+     * render time. For offline use each referenced URL is fetched and stored
+     * here, and `patchStyleForOffline` rewrites the dictionary entries to
+     * `idb://{styleId}/model/{name}` URLs.
+     */
+    class ModelService {
+        db = dbPromise;
+        /**
+         * Download the set of models referenced by `style.models` for one style.
+         *
+         * @param models   `{ modelName: resolvedHttpUrl }` — URLs must already be
+         *                 resolved (mapbox:// URLs should be resolved by the caller).
+         * @param styleId  The owning style's key.
+         */
+        async downloadModels(models, styleId, options = {}) {
+            const db = await this.db;
+            const { onProgress, batchSize = 4, maxRetries = 3, skipExisting = true, timeoutMs = 30000, } = options;
+            const entries = Object.entries(models);
+            const progressTracker = createProgressTracker(entries.length);
+            const result = {
+                totalModels: entries.length,
+                downloadedModels: 0,
+                skippedModels: 0,
+                failedModels: 0,
+                totalSize: 0,
+                errors: [],
+            };
+            const emit = () => onProgress?.(progressTracker.getProgress());
+            emit();
+            if (entries.length === 0)
+                return result;
+            // Pre-compute existing keys for skipExisting
+            const existingKeys = new Set();
+            if (skipExisting) {
+                const tx = db.transaction('models', 'readonly');
+                for await (const cursor of tx.store) {
+                    existingKeys.add(cursor.value.key);
+                }
+            }
+            await processBatch(entries, async ([modelName, url]) => {
+                const key = modelKey(styleId, modelName);
+                const label = `${styleId}::${modelName}`;
+                if (skipExisting && existingKeys.has(key)) {
+                    result.skippedModels++;
+                    progressTracker.update(1, label);
+                    emit();
+                    return;
+                }
+                try {
+                    const response = await fetchResourceWithRetry(url, {
+                        retries: maxRetries,
+                        timeout: timeoutMs,
+                        proxyType: 'tiles',
+                    });
+                    if (response.type === 'json') {
+                        throw new Error('Unexpected JSON response for model');
+                    }
+                    const data = response.data;
+                    const contentType = ('contentType' in response && response.contentType) || 'model/gltf-binary';
+                    const entry = {
+                        key,
+                        data,
+                        contentType,
+                        size: data.byteLength,
+                        url,
+                        styleId,
+                        modelName,
+                        lastModified: Date.now(),
+                        downloadedAt: new Date().toISOString(),
+                        expires: response.expires,
+                    };
+                    await db.put('models', entry);
+                    result.downloadedModels++;
+                    result.totalSize += data.byteLength;
+                    progressTracker.update(1, label);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    result.failedModels++;
+                    result.errors.push({ url, error: message });
+                    modelLogger.warn(`Failed to download model "${modelName}" from ${url}:`, err);
+                    progressTracker.update(1, label, message);
+                }
+                emit();
+            }, { batchSize });
+            modelLogger.info(`Models downloaded for style ${styleId}: ${result.downloadedModels} new, ${result.skippedModels} skipped, ${result.failedModels} failed`);
+            return result;
+        }
+        /** Retrieve a single model by `{styleId, modelName}`. */
+        async getModel(styleId, modelName) {
+            const db = await this.db;
+            return db.get('models', modelKey(styleId, modelName));
+        }
+        /** Aggregate stats across all stored models. */
+        async getModelStats() {
+            const db = await this.db;
+            const stats = {
+                count: 0,
+                totalSize: 0,
+                averageSize: 0,
+                models: [],
+                modelsByStyle: {},
+            };
+            const tx = db.transaction('models', 'readonly');
+            for await (const cursor of tx.store) {
+                const m = cursor.value;
+                stats.count++;
+                stats.totalSize += m.size;
+                stats.models.push({ name: m.modelName, size: m.size, lastModified: m.lastModified });
+                stats.modelsByStyle[m.styleId] = (stats.modelsByStyle[m.styleId] ?? 0) + 1;
+            }
+            stats.averageSize = stats.count > 0 ? stats.totalSize / stats.count : 0;
+            return stats;
+        }
+        /**
+         * Delete models older than `maxAge` days. Defaults to 30.
+         */
+        async cleanupOldModels(maxAge = 30) {
+            const db = await this.db;
+            const cutoff = Date.now() - maxAge * 24 * 60 * 60 * 1000;
+            let deleted = 0;
+            const tx = db.transaction('models', 'readwrite');
+            for await (const cursor of tx.store) {
+                if (cursor.value.lastModified < cutoff) {
+                    await cursor.delete();
+                    deleted++;
+                }
+            }
+            return deleted;
+        }
+        /**
+         * Basic integrity check: remove entries with empty/missing data.
+         */
+        async verifyAndRepairModels() {
+            const db = await this.db;
+            let verified = 0;
+            let removed = 0;
+            const tx = db.transaction('models', 'readwrite');
+            for await (const cursor of tx.store) {
+                const m = cursor.value;
+                if (!m.data || m.data.byteLength === 0) {
+                    await cursor.delete();
+                    removed++;
+                }
+                else {
+                    verified++;
+                }
+            }
+            return { verified, repaired: 0, removed };
+        }
+    }
+    // Singleton + convenience exports, matching other service modules.
+    const modelService = new ModelService();
+    const downloadModels = (models, styleId, options) => modelService.downloadModels(models, styleId, options);
+    const getModel = (styleId, modelName) => modelService.getModel(styleId, modelName);
+    const getModelStats = () => modelService.getModelStats();
+    const cleanupOldModels = (maxAge) => modelService.cleanupOldModels(maxAge);
+    const verifyAndRepairModels = () => modelService.verifyAndRepairModels();
+
+    var modelService$1 = /*#__PURE__*/Object.freeze({
+        __proto__: null,
+        ModelService: ModelService,
+        cleanupOldModels: cleanupOldModels,
+        downloadModels: downloadModels,
+        getModel: getModel,
+        getModelStats: getModelStats,
+        modelKeyBelongsToStyle: modelKeyBelongsToStyle,
+        modelService: modelService,
+        verifyAndRepairModels: verifyAndRepairModels
+    });
+
     class ResourceService {
         // Tile Management Methods
         async downloadTilesWithOptions(region, style, styleId, options = {}) {
@@ -7120,6 +7445,19 @@
         async verifyAndRepairGlyphs() {
             return verifyAndRepairGlyphs();
         }
+        // 3D Model Management Methods
+        async downloadModelsWithOptions(models, styleId, options = {}) {
+            return downloadModels(models, styleId, options);
+        }
+        async getModelStats() {
+            return getModelStats();
+        }
+        async cleanupOldModels(options) {
+            return cleanupOldModels(options?.maxAge);
+        }
+        async verifyAndRepairModels() {
+            return verifyAndRepairModels();
+        }
     }
 
     // The underlying stats functions already iterate every entry in their
@@ -7914,6 +8252,10 @@
         loadGlyphsForStyle: (...args) => services.resourceService.loadGlyphsForStyle(...args),
         cleanupOldGlyphs: (...args) => services.resourceService.cleanupOldGlyphs(...args),
         verifyAndRepairGlyphs: (...args) => services.resourceService.verifyAndRepairGlyphs(...args),
+        downloadModelsWithOptions: (...args) => services.resourceService.downloadModelsWithOptions(...args),
+        getModelStats: (...args) => services.resourceService.getModelStats(...args),
+        cleanupOldModels: (...args) => services.resourceService.cleanupOldModels(...args),
+        verifyAndRepairModels: (...args) => services.resourceService.verifyAndRepairModels(...args),
     });
 
     const createAnalyticsManagement = (services, deps) => ({
@@ -11560,10 +11902,12 @@
                                 panelLogger.debug(`Fixed legacy source ${sourceId}: added tiles, removed url`);
                             }
                         }
-                        // Apply maxzoom to all tile sources (including batched-model for 3D buildings)
+                        // Apply maxzoom to all tile sources (including batched-model for 3D
+                        // buildings and raster-array for Mapbox Standard landmark icons).
                         if (src.type === 'vector' ||
                             src.type === 'raster' ||
                             src.type === 'raster-dem' ||
+                            src.type === 'raster-array' ||
                             src.type === 'batched-model') {
                             const originalMaxzoom = src.maxzoom;
                             // Use the lower of region maxZoom and source's original maxzoom so we
@@ -13644,6 +13988,7 @@
     exports.MAPBOX_CLASSIC_STYLES = MAPBOX_CLASSIC_STYLES;
     exports.MAP_PROVIDERS = MAP_PROVIDERS;
     exports.MaintenanceService = MaintenanceService;
+    exports.ModelService = ModelService;
     exports.OfflineManagerControl = OfflineManagerControl;
     exports.OfflineMapDBVersionError = OfflineMapDBVersionError;
     exports.OfflineMapManager = OfflineMapManager;
@@ -13666,6 +14011,7 @@
     exports.cleanupExpiredTiles = cleanupExpiredTiles;
     exports.cleanupOldFonts = cleanupOldFonts;
     exports.cleanupOldGlyphs = cleanupOldGlyphs;
+    exports.cleanupOldModels = cleanupOldModels;
     exports.cleanupOldSprites = cleanupOldSprites;
     exports.cleanupOldStyles = cleanupOldStyles;
     exports.cleanupOldTiles = cleanupOldTiles;
@@ -13686,6 +14032,7 @@
     exports.detectStyleProvider = detectStyleProvider;
     exports.downloadFonts = downloadFonts;
     exports.downloadGlyphs = downloadGlyphs;
+    exports.downloadModels = downloadModels;
     exports.downloadSprites = downloadSprites;
     exports.downloadStyleWithProvider = downloadStyleWithProvider;
     exports.downloadStyles = downloadStyles;
@@ -13706,6 +14053,8 @@
     exports.getGlyphAnalytics = getGlyphAnalytics;
     exports.getGlyphStats = getGlyphStats;
     exports.getIcon = getIcon;
+    exports.getModel = getModel;
+    exports.getModelStats = getModelStats;
     exports.getRegionAnalytics = getRegionAnalytics;
     exports.getSpriteAnalytics = getSpriteAnalytics;
     exports.getSpriteStats = getSpriteStats;
@@ -13725,6 +14074,8 @@
     exports.loadStyleById = loadStyleById;
     exports.loadStyles = loadStyles;
     exports.logger = logger;
+    exports.modelKeyBelongsToStyle = modelKeyBelongsToStyle;
+    exports.modelService = modelService;
     exports.normalizeSpriteProperty = normalizeSpriteProperty;
     exports.normalizeStyleUrl = normalizeStyleUrl;
     exports.optimizeStorage = optimizeStorage;
@@ -13754,6 +14105,7 @@
     exports.validateZoomLevels = validateZoomLevels;
     exports.verifyAndRepairFonts = verifyAndRepairFonts;
     exports.verifyAndRepairGlyphs = verifyAndRepairGlyphs;
+    exports.verifyAndRepairModels = verifyAndRepairModels;
     exports.verifyAndRepairSprites = verifyAndRepairSprites;
 
     Object.defineProperty(exports, '__esModule', { value: true });