@itwin/map-layers-formats 4.0.0-dev.52 → 4.0.0-dev.55

package/lib/cjs/ArcGisFeature/ArcGisFeaturePBF.js

@@ -1,201 +1,201 @@
-"use strict";
-/*---------------------------------------------------------------------------------------------
-* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
-* See LICENSE.md in the project root for license terms and full copyright notice.
-*--------------------------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArcGisFeaturePBF = void 0;
-const esriPBuffer_gen_1 = require("../ArcGisFeature/esriPBuffer.gen");
-const core_frontend_1 = require("@itwin/core-frontend");
-const appui_abstract_1 = require("@itwin/appui-abstract");
-const ArcGisFeatureReader_1 = require("./ArcGisFeatureReader");
-const core_bentley_1 = require("@itwin/core-bentley");
-const esriGeometryType = esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType;
-const loggerCategory = "MapLayersFormats.ArcGISFeature";
-/** @internal */
-class ArcGisFeaturePBF extends ArcGisFeatureReader_1.ArcGisFeatureReader {
-    constructor(settings, layerMetadata) {
-        super(settings, layerMetadata);
-    }
-    static getArcGisFeatureGeometryType(geomType) {
-        switch (geomType) {
-            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypeMultipatch:
-                return "esriGeometryMultiPatch";
-            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypeMultipoint:
-                return "esriGeometryMultipoint";
-            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypePoint:
-                return "esriGeometryPoint";
-            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypePolygon:
-                return "esriGeometryPolygon";
-            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypePolyline:
-                return "esriGeometryPolyline";
-            default:
-                return "esriGeometryNull";
-        }
-    }
-    readAndRender(response, renderer) {
-        if (!(response.data instanceof esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer)) {
-            const msg = "Response was not in PBF format";
-            core_bentley_1.Logger.logError(loggerCategory, msg);
-            return;
-        }
-        const collection = response.data;
-        if (!collection.has_queryResult || !collection.queryResult.has_featureResult || collection?.queryResult?.featureResult?.features === undefined)
-            return;
-        const geomType = collection.queryResult.featureResult.geometryType;
-        const stride = (collection.queryResult.featureResult.hasM || collection.queryResult.featureResult.hasZ) ? 3 : 2;
-        // console.log(`Nb Feature: ${collection.queryResult.featureResult.features.length}`);
-        if (geomType === esriGeometryType.esriGeometryTypePoint ||
-            geomType === esriGeometryType.esriGeometryTypeMultipoint) {
-            for (const feature of collection.queryResult.featureResult.features)
-                renderer.renderPoint(feature.geometry.lengths, feature.geometry.coords, stride, renderer.transform === undefined);
-        }
-        else if (geomType === esriGeometryType.esriGeometryTypePolyline || geomType === esriGeometryType.esriGeometryTypePolygon) {
-            const fill = (geomType === esriGeometryType.esriGeometryTypePolygon);
-            for (const feature of collection.queryResult.featureResult.features)
-                if (feature?.has_geometry)
-                    renderer.renderPath(feature.geometry.lengths, feature.geometry.coords, fill, stride, renderer.transform === undefined);
-        }
-    }
-    readFeatureInfo(response, featureInfos) {
-        if (!(response.data instanceof esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer)) {
-            core_bentley_1.Logger.logError(loggerCategory, "Response was not in PBF format");
-        }
-        const collection = response.data;
-        if (!collection.has_queryResult || !collection.queryResult.has_featureResult || collection?.queryResult?.featureResult?.features === undefined)
-            return;
-        const layerInfo = { layerName: this._settings.name, info: [] };
-        // Fields metadata is stored outside feature results, create dedicated array first
-        const fields = [];
-        for (const field of collection.queryResult.featureResult.fields)
-            fields.push({ name: field.name, type: field.fieldType });
-        const getNumericValue = (attrValue) => {
-            const propertyValue = { valueFormat: appui_abstract_1.PropertyValueFormat.Primitive };
-            let typename = appui_abstract_1.StandardTypeNames.Number;
-            if (attrValue.has_double_value) {
-                const value = this.toFixedWithoutPadding(attrValue.double_value);
-                propertyValue.value = value;
-                typename = appui_abstract_1.StandardTypeNames.Double;
-            }
-            else if (attrValue.has_float_value) {
-                const value = this.toFixedWithoutPadding(attrValue.float_value);
-                propertyValue.value = value;
-                typename = appui_abstract_1.StandardTypeNames.Float;
-            }
-            else if (attrValue.has_int64_value) {
-                propertyValue.value = attrValue.int64_value;
-                typename = appui_abstract_1.StandardTypeNames.Integer;
-            }
-            else if (attrValue.has_sint64_value) {
-                propertyValue.value = attrValue.sint64_value;
-                typename = appui_abstract_1.StandardTypeNames.Integer;
-            }
-            else if (attrValue.has_sint_value) {
-                propertyValue.value = attrValue.sint_value;
-                typename = appui_abstract_1.StandardTypeNames.Integer;
-            }
-            else if (attrValue.has_uint64_value) {
-                propertyValue.value = attrValue.uint64_value;
-                typename = appui_abstract_1.StandardTypeNames.Integer;
-            }
-            else if (attrValue.has_uint_value) {
-                propertyValue.value = attrValue.uint_value;
-                typename = appui_abstract_1.StandardTypeNames.Integer;
-            }
-            else {
-                propertyValue.value = undefined;
-            }
-            return { propertyValue, typename };
-        };
-        const getRecordInfo = (fieldInfo, attrValue) => {
-            let propertyValue = { valueFormat: appui_abstract_1.PropertyValueFormat.Primitive };
-            let typename = appui_abstract_1.StandardTypeNames.String;
-            if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeDouble
-                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeInteger
-                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeSmallInteger
-                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeOID
-                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeSingle
-                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeDate) {
-                const value = getNumericValue(attrValue);
-                if (value.propertyValue === undefined) {
-                    core_bentley_1.Logger.logError(loggerCategory, `Could not read numeric value for field ${fieldInfo.name}`);
-                    return undefined;
-                }
-                if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeDate) {
-                    const test = value.propertyValue.value;
-                    propertyValue.value = new Date(test);
-                    typename = appui_abstract_1.StandardTypeNames.DateTime;
-                }
-                else {
-                    typename = value.typename;
-                    propertyValue = value.propertyValue;
-                }
-            }
-            else if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeString) {
-                if (attrValue.has_string_value) {
-                    propertyValue.value = attrValue.string_value;
-                    typename = appui_abstract_1.StandardTypeNames.String;
-                }
-            }
-            else if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeGlobalID) {
-                if (attrValue.has_string_value) {
-                    propertyValue.value = attrValue.string_value;
-                    typename = appui_abstract_1.StandardTypeNames.String;
-                }
-                else {
-                    const value = getNumericValue(attrValue);
-                    if (value.propertyValue === undefined) {
-                        core_bentley_1.Logger.logError(loggerCategory, `Could not read GlobalId value for field ${fieldInfo.name}`);
-                        return undefined;
-                    }
-                }
-            }
-            else if (attrValue.has_string_value) {
-                // If we reach this case that probably mean we don't support the field type, simply try to output string value
-                typename = appui_abstract_1.StandardTypeNames.String;
-                propertyValue.value = attrValue.string_value;
-            }
-            else if (attrValue.value_type === "none") {
-                // Sometimes fields are just empty, use an empty string
-                typename = appui_abstract_1.StandardTypeNames.String;
-                propertyValue.value = undefined;
-            }
-            else {
-                core_bentley_1.Logger.logError(loggerCategory, `Could not read value for field ${fieldInfo.name}`);
-                return undefined;
-            }
-            propertyValue.displayValue = this.getDisplayValue(typename, propertyValue.value);
-            return new core_frontend_1.MapFeatureInfoRecord(propertyValue, { name: fieldInfo.name, displayLabel: fieldInfo.name, typename });
-        };
-        // Read feature values
-        for (const feature of collection.queryResult.featureResult.features) {
-            const subLayerInfo = {
-                subLayerName: this._layerMetadata.name,
-                displayFieldName: this._layerMetadata.name,
-                records: [],
-            };
-            let i = 0;
-            for (const attrValue of feature.attributes) {
-                if (i > fields.length) {
-                    core_bentley_1.Logger.logError(loggerCategory, "Error while read feature info data: fields metadata missing");
-                    break;
-                }
-                // Convert everything to string for now
-                const info = getRecordInfo(fields[i], attrValue);
-                if (info) {
-                    subLayerInfo.records?.push(info);
-                }
-                i++;
-            }
-            if (layerInfo.info === undefined) {
-                layerInfo.info = [];
-            }
-            if (!(layerInfo.info instanceof HTMLElement)) {
-                layerInfo.info.push(subLayerInfo);
-            }
-        }
-        featureInfos.push(layerInfo);
-    }
-}
-exports.ArcGisFeaturePBF = ArcGisFeaturePBF;
+"use strict";
+/*---------------------------------------------------------------------------------------------
+* Copyright (c) Bentley Systems, Incorporated. All rights reserved.
+* See LICENSE.md in the project root for license terms and full copyright notice.
+*--------------------------------------------------------------------------------------------*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArcGisFeaturePBF = void 0;
+const esriPBuffer_gen_1 = require("../ArcGisFeature/esriPBuffer.gen");
+const core_frontend_1 = require("@itwin/core-frontend");
+const appui_abstract_1 = require("@itwin/appui-abstract");
+const ArcGisFeatureReader_1 = require("./ArcGisFeatureReader");
+const core_bentley_1 = require("@itwin/core-bentley");
+const esriGeometryType = esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType;
+const loggerCategory = "MapLayersFormats.ArcGISFeature";
+/** @internal */
+class ArcGisFeaturePBF extends ArcGisFeatureReader_1.ArcGisFeatureReader {
+    constructor(settings, layerMetadata) {
+        super(settings, layerMetadata);
+    }
+    static getArcGisFeatureGeometryType(geomType) {
+        switch (geomType) {
+            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypeMultipatch:
+                return "esriGeometryMultiPatch";
+            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypeMultipoint:
+                return "esriGeometryMultipoint";
+            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypePoint:
+                return "esriGeometryPoint";
+            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypePolygon:
+                return "esriGeometryPolygon";
+            case esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.GeometryType.esriGeometryTypePolyline:
+                return "esriGeometryPolyline";
+            default:
+                return "esriGeometryNull";
+        }
+    }
+    readAndRender(response, renderer) {
+        if (!(response.data instanceof esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer)) {
+            const msg = "Response was not in PBF format";
+            core_bentley_1.Logger.logError(loggerCategory, msg);
+            return;
+        }
+        const collection = response.data;
+        if (!collection.has_queryResult || !collection.queryResult.has_featureResult || collection?.queryResult?.featureResult?.features === undefined)
+            return;
+        const geomType = collection.queryResult.featureResult.geometryType;
+        const stride = (collection.queryResult.featureResult.hasM || collection.queryResult.featureResult.hasZ) ? 3 : 2;
+        // console.log(`Nb Feature: ${collection.queryResult.featureResult.features.length}`);
+        if (geomType === esriGeometryType.esriGeometryTypePoint ||
+            geomType === esriGeometryType.esriGeometryTypeMultipoint) {
+            for (const feature of collection.queryResult.featureResult.features)
+                renderer.renderPoint(feature.geometry.lengths, feature.geometry.coords, stride, renderer.transform === undefined);
+        }
+        else if (geomType === esriGeometryType.esriGeometryTypePolyline || geomType === esriGeometryType.esriGeometryTypePolygon) {
+            const fill = (geomType === esriGeometryType.esriGeometryTypePolygon);
+            for (const feature of collection.queryResult.featureResult.features)
+                if (feature?.has_geometry)
+                    renderer.renderPath(feature.geometry.lengths, feature.geometry.coords, fill, stride, renderer.transform === undefined);
+        }
+    }
+    readFeatureInfo(response, featureInfos) {
+        if (!(response.data instanceof esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer)) {
+            core_bentley_1.Logger.logError(loggerCategory, "Response was not in PBF format");
+        }
+        const collection = response.data;
+        if (!collection.has_queryResult || !collection.queryResult.has_featureResult || collection?.queryResult?.featureResult?.features === undefined)
+            return;
+        const layerInfo = { layerName: this._settings.name, info: [] };
+        // Fields metadata is stored outside feature results, create dedicated array first
+        const fields = [];
+        for (const field of collection.queryResult.featureResult.fields)
+            fields.push({ name: field.name, type: field.fieldType });
+        const getNumericValue = (attrValue) => {
+            const propertyValue = { valueFormat: appui_abstract_1.PropertyValueFormat.Primitive };
+            let typename = appui_abstract_1.StandardTypeNames.Number;
+            if (attrValue.has_double_value) {
+                const value = this.toFixedWithoutPadding(attrValue.double_value);
+                propertyValue.value = value;
+                typename = appui_abstract_1.StandardTypeNames.Double;
+            }
+            else if (attrValue.has_float_value) {
+                const value = this.toFixedWithoutPadding(attrValue.float_value);
+                propertyValue.value = value;
+                typename = appui_abstract_1.StandardTypeNames.Float;
+            }
+            else if (attrValue.has_int64_value) {
+                propertyValue.value = attrValue.int64_value;
+                typename = appui_abstract_1.StandardTypeNames.Integer;
+            }
+            else if (attrValue.has_sint64_value) {
+                propertyValue.value = attrValue.sint64_value;
+                typename = appui_abstract_1.StandardTypeNames.Integer;
+            }
+            else if (attrValue.has_sint_value) {
+                propertyValue.value = attrValue.sint_value;
+                typename = appui_abstract_1.StandardTypeNames.Integer;
+            }
+            else if (attrValue.has_uint64_value) {
+                propertyValue.value = attrValue.uint64_value;
+                typename = appui_abstract_1.StandardTypeNames.Integer;
+            }
+            else if (attrValue.has_uint_value) {
+                propertyValue.value = attrValue.uint_value;
+                typename = appui_abstract_1.StandardTypeNames.Integer;
+            }
+            else {
+                propertyValue.value = undefined;
+            }
+            return { propertyValue, typename };
+        };
+        const getRecordInfo = (fieldInfo, attrValue) => {
+            let propertyValue = { valueFormat: appui_abstract_1.PropertyValueFormat.Primitive };
+            let typename = appui_abstract_1.StandardTypeNames.String;
+            if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeDouble
+                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeInteger
+                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeSmallInteger
+                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeOID
+                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeSingle
+                || fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeDate) {
+                const value = getNumericValue(attrValue);
+                if (value.propertyValue === undefined) {
+                    core_bentley_1.Logger.logError(loggerCategory, `Could not read numeric value for field ${fieldInfo.name}`);
+                    return undefined;
+                }
+                if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeDate) {
+                    const test = value.propertyValue.value;
+                    propertyValue.value = new Date(test);
+                    typename = appui_abstract_1.StandardTypeNames.DateTime;
+                }
+                else {
+                    typename = value.typename;
+                    propertyValue = value.propertyValue;
+                }
+            }
+            else if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeString) {
+                if (attrValue.has_string_value) {
+                    propertyValue.value = attrValue.string_value;
+                    typename = appui_abstract_1.StandardTypeNames.String;
+                }
+            }
+            else if (fieldInfo.type === esriPBuffer_gen_1.esriPBuffer.FeatureCollectionPBuffer.FieldType.esriFieldTypeGlobalID) {
+                if (attrValue.has_string_value) {
+                    propertyValue.value = attrValue.string_value;
+                    typename = appui_abstract_1.StandardTypeNames.String;
+                }
+                else {
+                    const value = getNumericValue(attrValue);
+                    if (value.propertyValue === undefined) {
+                        core_bentley_1.Logger.logError(loggerCategory, `Could not read GlobalId value for field ${fieldInfo.name}`);
+                        return undefined;
+                    }
+                }
+            }
+            else if (attrValue.has_string_value) {
+                // If we reach this case that probably mean we don't support the field type, simply try to output string value
+                typename = appui_abstract_1.StandardTypeNames.String;
+                propertyValue.value = attrValue.string_value;
+            }
+            else if (attrValue.value_type === "none") {
+                // Sometimes fields are just empty, use an empty string
+                typename = appui_abstract_1.StandardTypeNames.String;
+                propertyValue.value = undefined;
+            }
+            else {
+                core_bentley_1.Logger.logError(loggerCategory, `Could not read value for field ${fieldInfo.name}`);
+                return undefined;
+            }
+            propertyValue.displayValue = this.getDisplayValue(typename, propertyValue.value);
+            return new core_frontend_1.MapFeatureInfoRecord(propertyValue, { name: fieldInfo.name, displayLabel: fieldInfo.name, typename });
+        };
+        // Read feature values
+        for (const feature of collection.queryResult.featureResult.features) {
+            const subLayerInfo = {
+                subLayerName: this._layerMetadata.name,
+                displayFieldName: this._layerMetadata.name,
+                records: [],
+            };
+            let i = 0;
+            for (const attrValue of feature.attributes) {
+                if (i > fields.length) {
+                    core_bentley_1.Logger.logError(loggerCategory, "Error while read feature info data: fields metadata missing");
+                    break;
+                }
+                // Convert everything to string for now
+                const info = getRecordInfo(fields[i], attrValue);
+                if (info) {
+                    subLayerInfo.records?.push(info);
+                }
+                i++;
+            }
+            if (layerInfo.info === undefined) {
+                layerInfo.info = [];
+            }
+            if (!(layerInfo.info instanceof HTMLElement)) {
+                layerInfo.info.push(subLayerInfo);
+            }
+        }
+        featureInfos.push(layerInfo);
+    }
+}
+exports.ArcGisFeaturePBF = ArcGisFeaturePBF;
 //# sourceMappingURL=ArcGisFeaturePBF.js.map

package/lib/cjs/ArcGisFeature/ArcGisFeatureProvider.d.ts

@@ -1,45 +1,45 @@
-import { Cartographic, ImageMapLayerSettings, ImageSource } from "@itwin/core-common";
-import { Transform } from "@itwin/core-geometry";
-import { ArcGISImageryProvider, ImageryMapTileTree, MapLayerFeatureInfo, QuadId } from "@itwin/core-frontend";
-import { ArcGisExtent, ArcGisFeatureFormat, ArcGisGeometry } from "./ArcGisFeatureQuery";
-/**
-* @internal
-*/
-interface ArcGisFeatureUrl {
-    url: string;
-    envelope?: ArcGisExtent;
-}
-/**  Provide tiles from a ESRI ArcGIS Feature service
-* @internal
-*/
-export declare class ArcGisFeatureProvider extends ArcGISImageryProvider {
-    private _drawDebugInfo;
-    private _debugFeatureGeom;
-    private _supportsCoordinatesQuantization;
-    private _querySupported;
-    private _layerId;
-    private _layerMetadata;
-    private _format;
-    serviceJson: any;
-    private _symbologyRenderer;
-    private static readonly _nbSubTiles;
-    private _outSR;
-    private _maxDepthFromLod;
-    private _minDepthFromLod;
-    get minimumZoomLevel(): number;
-    get maximumZoomLevel(): number;
-    constructor(settings: ImageMapLayerSettings);
-    initialize(): Promise<void>;
-    protected getLayerMetadata(layerId: number): Promise<any>;
-    get tileSize(): number;
-    get format(): ArcGisFeatureFormat | undefined;
-    constructUrl(_row: number, _column: number, _zoomLevel: number): Promise<string>;
-    constructFeatureUrl(row: number, column: number, zoomLevel: number, format: ArcGisFeatureFormat, geomOverride?: ArcGisGeometry, outFields?: string, tolerance?: number, returnGeometry?: boolean): ArcGisFeatureUrl | undefined;
-    getFeatureInfo(featureInfos: MapLayerFeatureInfo[], quadId: QuadId, carto: Cartographic, _tree: ImageryMapTileTree): Promise<void>;
-    private fetchTile;
-    drawTileDebugInfo(row: number, column: number, zoomLevel: number, context: CanvasRenderingContext2D): void;
-    protected computeTileWorld2CanvasTransform(row: number, column: number, zoomLevel: number): Transform | undefined;
-    loadTile(row: number, column: number, zoomLevel: number): Promise<ImageSource | undefined>;
-}
-export {};
+import { Cartographic, ImageMapLayerSettings, ImageSource } from "@itwin/core-common";
+import { Transform } from "@itwin/core-geometry";
+import { ArcGISImageryProvider, ImageryMapTileTree, MapLayerFeatureInfo, QuadId } from "@itwin/core-frontend";
+import { ArcGisExtent, ArcGisFeatureFormat, ArcGisGeometry } from "./ArcGisFeatureQuery";
+/**
+* @internal
+*/
+interface ArcGisFeatureUrl {
+    url: string;
+    envelope?: ArcGisExtent;
+}
+/**  Provide tiles from a ESRI ArcGIS Feature service
+* @internal
+*/
+export declare class ArcGisFeatureProvider extends ArcGISImageryProvider {
+    private _drawDebugInfo;
+    private _debugFeatureGeom;
+    private _supportsCoordinatesQuantization;
+    private _querySupported;
+    private _layerId;
+    private _layerMetadata;
+    private _format;
+    serviceJson: any;
+    private _symbologyRenderer;
+    private static readonly _nbSubTiles;
+    private _outSR;
+    private _maxDepthFromLod;
+    private _minDepthFromLod;
+    get minimumZoomLevel(): number;
+    get maximumZoomLevel(): number;
+    constructor(settings: ImageMapLayerSettings);
+    initialize(): Promise<void>;
+    protected getLayerMetadata(layerId: number): Promise<any>;
+    get tileSize(): number;
+    get format(): ArcGisFeatureFormat | undefined;
+    constructUrl(_row: number, _column: number, _zoomLevel: number): Promise<string>;
+    constructFeatureUrl(row: number, column: number, zoomLevel: number, format: ArcGisFeatureFormat, geomOverride?: ArcGisGeometry, outFields?: string, tolerance?: number, returnGeometry?: boolean): ArcGisFeatureUrl | undefined;
+    getFeatureInfo(featureInfos: MapLayerFeatureInfo[], quadId: QuadId, carto: Cartographic, _tree: ImageryMapTileTree): Promise<void>;
+    private fetchTile;
+    drawTileDebugInfo(row: number, column: number, zoomLevel: number, context: CanvasRenderingContext2D): void;
+    protected computeTileWorld2CanvasTransform(row: number, column: number, zoomLevel: number): Transform | undefined;
+    loadTile(row: number, column: number, zoomLevel: number): Promise<ImageSource | undefined>;
+}
+export {};
 //# sourceMappingURL=ArcGisFeatureProvider.d.ts.map