@honua/sdk-esri-compat 0.0.6-alpha.0

package/core/surfaces.js

@@ -0,0 +1,1322 @@
+export class HonuaService {
+    client;
+    serviceId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+    }
+    featureLayer(layerId) {
+        return new HonuaFeatureLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        });
+    }
+    layer(layerId) {
+        return this.featureLayer(layerId);
+    }
+    async featureServiceMetadata(options = {}) {
+        return this.client.getFeatureServiceMetadata(this.serviceId, options);
+    }
+    async mapServiceMetadata(options = {}) {
+        return this.client.getMapServiceMetadata(this.serviceId, options);
+    }
+    async featureLayerIds() {
+        const metadata = await this.featureServiceMetadata();
+        return extractLayerIds(metadata);
+    }
+    async featureLayers() {
+        const ids = await this.featureLayerIds();
+        return ids.map((layerId) => new HonuaFeatureLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        }));
+    }
+    async mapLayerIds() {
+        const metadata = await this.mapServiceMetadata();
+        return extractLayerIds(metadata);
+    }
+    async mapLayers() {
+        const ids = await this.mapLayerIds();
+        return ids.map((layerId) => new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        }));
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}/${normalizeServicePath(request.path)}`,
+        });
+    }
+    mapService() {
+        return new HonuaMapService({
+            client: this.client,
+            serviceId: this.serviceId,
+        });
+    }
+    mapLayer(layerId) {
+        return new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        });
+    }
+}
+export class HonuaFeatureLayer {
+    client;
+    serviceId;
+    layerId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.layerId = options.layerId;
+    }
+    async metadata(options = {}) {
+        return this.client.getLayerMetadata(this.serviceId, this.layerId, options);
+    }
+    createQuery() {
+        return {
+            where: "1=1",
+            outFields: ["*"],
+            returnGeometry: true,
+        };
+    }
+    async queryFeatures(request = {}) {
+        return this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryFeaturesAll(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: startingOffset + page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = response.features ?? [];
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryFeaturesStream(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        // Use server streaming RPC when gRPC-Web transport is active
+        if (this.client.isGrpcWeb) {
+            const { pageSize: _pageSize, maxPages: _maxPages, ...queryRequest } = request;
+            let pageCount = 0;
+            const stream = this.client.queryFeaturesStream({
+                serviceId: this.serviceId,
+                layerId: this.layerId,
+                ...queryRequest,
+                resultRecordCount: queryRequest.resultRecordCount ?? pageSize,
+            });
+            for await (const page of stream) {
+                yield page;
+                pageCount += 1;
+                if (pageCount >= maxPages) {
+                    break;
+                }
+            }
+            return;
+        }
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: startingOffset + page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = response.features ?? [];
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryFeatureCount(request = {}) {
+        const response = await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...request.extraParams,
+            },
+        });
+        if (isObject(response) && typeof response.count === "number" && Number.isFinite(response.count)) {
+            return response.count;
+        }
+        if (isObject(response) && Array.isArray(response.features)) {
+            return response.features.length;
+        }
+        return 0;
+    }
+    async queryObjectIds(request = {}) {
+        const response = await this.client.queryFeatures({
+            ...request,
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: request.outFields ?? "OBJECTID",
+            extraParams: {
+                returnIdsOnly: true,
+                ...request.extraParams,
+            },
+        });
+        if (isObject(response) && Array.isArray(response.objectIds)) {
+            return response.objectIds
+                .map((value) => Number(value))
+                .filter((value) => Number.isFinite(value));
+        }
+        return [];
+    }
+    async queryExtent(request = {}) {
+        const response = await this.client.queryFeatures({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            method: request.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractExtentFromResponse(response);
+    }
+    async queryRelatedRecords(request) {
+        return this.client.queryRelatedRecords({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryRelatedFeatures(request) {
+        return this.queryRelatedRecords(request);
+    }
+    async applyEdits(request) {
+        return this.client.applyEdits({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryAttachments(request = {}) {
+        const method = request.method ?? "GET";
+        const path = `/rest/services/${encodeURIComponent(this.serviceId)}` + `/FeatureServer/${this.layerId}/queryAttachments`;
+        const query = {
+            ...(request.objectIds === undefined
+                ? {}
+                : {
+                    objectIds: normalizeObjectIds(request.objectIds),
+                }),
+            ...(request.where === undefined ? {} : { where: request.where }),
+            ...(request.extraParams ?? {}),
+        };
+        if (method === "GET") {
+            return this.client.request({
+                method: "GET",
+                path,
+                responseFormat: request.responseFormat ?? "json",
+                query,
+                signal: request.signal,
+            });
+        }
+        const body = toFormBody({
+            f: request.responseFormat ?? "json",
+            ...query,
+        });
+        return this.client.request({
+            method: "POST",
+            path,
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body,
+            signal: request.signal,
+        });
+    }
+    async listAttachments(request) {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/attachments`,
+            responseFormat: request.responseFormat ?? "json",
+            query: request.extraParams,
+            signal: request.signal,
+        });
+    }
+    async deleteAttachments(request) {
+        const body = toFormBody({
+            f: request.responseFormat ?? "json",
+            attachmentIds: normalizeObjectIds(request.attachmentIds),
+            ...(request.extraParams ?? {}),
+        });
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/deleteAttachments`,
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+            },
+            body,
+            signal: request.signal,
+        });
+    }
+    async addAttachment(request) {
+        const form = buildAttachmentFormData(request);
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/addAttachment`,
+            responseFormat: request.responseFormat ?? "json",
+            query: request.extraParams,
+            body: form,
+            signal: request.signal,
+        });
+    }
+    async updateAttachment(request) {
+        const form = buildAttachmentFormData(request);
+        form.set("attachmentId", String(request.attachmentId));
+        return this.client.request({
+            method: "POST",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${request.objectId}/updateAttachment`,
+            responseFormat: request.responseFormat ?? "json",
+            query: request.extraParams,
+            body: form,
+            signal: request.signal,
+        });
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/FeatureServer/${this.layerId}/${normalizeLayerPath(request.path)}`,
+        });
+    }
+}
+export class HonuaMapService {
+    client;
+    serviceId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+    }
+    async metadata(options = {}) {
+        return this.client.getMapServiceMetadata(this.serviceId, options);
+    }
+    layer(layerId) {
+        return new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        });
+    }
+    async layerIds() {
+        const metadata = await this.metadata();
+        return extractLayerIds(metadata);
+    }
+    async layers() {
+        const ids = await this.layerIds();
+        return ids.map((layerId) => new HonuaMapLayer({
+            client: this.client,
+            serviceId: this.serviceId,
+            layerId,
+        }));
+    }
+    async exportMap(request) {
+        return this.client.exportMap({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async legend(request = {}) {
+        return this.client.getMapLegend({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async getLegend(request = {}) {
+        return this.legend(request);
+    }
+    async identify(request) {
+        return this.client.identifyMap({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async find(request) {
+        return this.client.findMap({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async queryLayer(request) {
+        return this.client.queryMapLayer({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async queryLayerRelatedRecords(request) {
+        return this.client.queryMapRelatedRecords({
+            serviceId: this.serviceId,
+            ...request,
+        });
+    }
+    async queryLayerRelatedFeatures(request) {
+        return this.queryLayerRelatedRecords(request);
+    }
+    async queryLayerFeaturesAll(request) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryLayer({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryLayerFeaturesStream(request) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryLayer({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryLayerFeatureCount(request) {
+        const response = await this.queryLayer({
+            layerId: request.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractFeatureCountFromResponse(response);
+    }
+    async queryLayerObjectIds(request) {
+        const response = await this.queryLayer({
+            layerId: request.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnIdsOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractObjectIdsFromResponse(response);
+    }
+    async queryLayerExtent(request) {
+        const response = await this.queryLayer({
+            layerId: request.layerId,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            method: request.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractExtentFromResponse(response);
+    }
+    async exportImage(request) {
+        return this.exportMap(request);
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` + `/MapServer/${normalizeServicePath(request.path)}`,
+        });
+    }
+}
+export class HonuaMapLayer {
+    client;
+    serviceId;
+    layerId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.layerId = options.layerId;
+    }
+    async metadata(options = {}) {
+        return this.client.getMapLayerMetadata(this.serviceId, this.layerId, options);
+    }
+    createQuery() {
+        return {
+            where: "1=1",
+            outFields: ["*"],
+            returnGeometry: true,
+        };
+    }
+    async queryFeatures(request = {}) {
+        return this.client.queryMapLayer({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryRelatedRecords(request) {
+        return this.client.queryMapRelatedRecords({
+            serviceId: this.serviceId,
+            layerId: this.layerId,
+            ...request,
+        });
+    }
+    async queryRelatedFeatures(request) {
+        return this.queryRelatedRecords(request);
+    }
+    async queryFeaturesAll(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: startingOffset + page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+        return features;
+    }
+    async *queryFeaturesStream(request = {}) {
+        const pageSize = typeof request.pageSize === "number" && Number.isFinite(request.pageSize)
+            ? Math.max(1, Math.trunc(request.pageSize))
+            : 2000;
+        const maxPages = typeof request.maxPages === "number" && Number.isFinite(request.maxPages)
+            ? Math.max(1, Math.trunc(request.maxPages))
+            : 100;
+        const startingOffset = normalizeOffset(request.resultOffset);
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.queryFeatures({
+                ...request,
+                extraParams: {
+                    ...(request.extraParams ?? {}),
+                    resultOffset: startingOffset + page * pageSize,
+                    resultRecordCount: pageSize,
+                },
+            });
+            const pageFeatures = extractFeaturesFromResponse(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async queryFeatureCount(request = {}) {
+        const response = await this.queryFeatures({
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: "OBJECTID",
+            method: request.method,
+            extraParams: {
+                returnCountOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractFeatureCountFromResponse(response);
+    }
+    async queryObjectIds(request = {}) {
+        const response = await this.queryFeatures({
+            ...request,
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            outFields: request.outFields ?? "OBJECTID",
+            extraParams: {
+                returnIdsOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractObjectIdsFromResponse(response);
+    }
+    async queryExtent(request = {}) {
+        const response = await this.queryFeatures({
+            where: request.where ?? "1=1",
+            returnGeometry: false,
+            method: request.method,
+            extraParams: {
+                returnExtentOnly: true,
+                ...request.extraParams,
+            },
+        });
+        return extractExtentFromResponse(response);
+    }
+    async request(request) {
+        return this.client.request({
+            ...request,
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}` +
+                `/MapServer/${this.layerId}/${normalizeLayerPath(request.path)}`,
+        });
+    }
+}
+export class HonuaOgcFeatures {
+    client;
+    constructor(options) {
+        this.client = options.client;
+    }
+    collection(collectionId) {
+        return new HonuaOgcFeatureCollection({
+            client: this.client,
+            collectionId,
+        });
+    }
+    async landing(request = {}) {
+        return this.client.getOgcFeaturesLanding(request);
+    }
+    async conformance(request = {}) {
+        return this.client.getOgcFeaturesConformance(request);
+    }
+    async collections(request = {}) {
+        return this.client.listOgcCollections(request);
+    }
+    async getCollection(request) {
+        return this.client.getOgcCollection(request);
+    }
+    async queryables(request) {
+        return this.client.getOgcQueryables(request);
+    }
+    async items(request) {
+        return this.client.listOgcItems(request);
+    }
+    async itemsAll(request) {
+        const pageSize = normalizePageSize(request.pageSize, request.limit);
+        const maxPages = normalizeMaxPages(request.maxPages);
+        const offset = normalizeOffset(request.offset);
+        const totalLimit = normalizeTotalLimit(request.limit);
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            if (totalLimit !== undefined && features.length >= totalLimit) {
+                break;
+            }
+            const remainingLimit = totalLimit === undefined ? pageSize : Math.max(0, totalLimit - features.length);
+            if (remainingLimit < 1) {
+                break;
+            }
+            const limit = Math.min(pageSize, remainingLimit);
+            const response = await this.items({
+                ...request,
+                limit,
+                offset: offset + page * pageSize,
+            });
+            const pageFeatures = extractOgcFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < limit) {
+                break;
+            }
+        }
+        if (totalLimit !== undefined && features.length > totalLimit) {
+            return features.slice(0, totalLimit);
+        }
+        return features;
+    }
+    async item(request) {
+        return this.client.getOgcItem(request);
+    }
+    async createItem(request) {
+        return this.client.createOgcItem(request);
+    }
+    async replaceItem(request) {
+        return this.client.replaceOgcItem(request);
+    }
+    async patchItem(request) {
+        return this.client.patchOgcItem(request);
+    }
+    async deleteItem(request) {
+        return this.client.deleteOgcItem(request);
+    }
+}
+export class HonuaOgcFeatureCollection {
+    client;
+    collectionId;
+    constructor(options) {
+        this.client = options.client;
+        this.collectionId = options.collectionId;
+    }
+    async metadata(request = {}) {
+        return this.client.getOgcCollection({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async queryables(request = {}) {
+        return this.client.getOgcQueryables({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async items(request = {}) {
+        return this.client.listOgcItems({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async itemsAll(request = {}) {
+        const pageSize = normalizePageSize(request.pageSize, request.limit);
+        const maxPages = normalizeMaxPages(request.maxPages);
+        const offset = normalizeOffset(request.offset);
+        const totalLimit = normalizeTotalLimit(request.limit);
+        const features = [];
+        for (let page = 0; page < maxPages; page += 1) {
+            if (totalLimit !== undefined && features.length >= totalLimit) {
+                break;
+            }
+            const remainingLimit = totalLimit === undefined ? pageSize : Math.max(0, totalLimit - features.length);
+            if (remainingLimit < 1) {
+                break;
+            }
+            const limit = Math.min(pageSize, remainingLimit);
+            const response = await this.items({
+                ...request,
+                limit,
+                offset: offset + page * pageSize,
+            });
+            const pageFeatures = extractOgcFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            features.push(...pageFeatures);
+            if (pageFeatures.length < limit) {
+                break;
+            }
+        }
+        if (totalLimit !== undefined && features.length > totalLimit) {
+            return features.slice(0, totalLimit);
+        }
+        return features;
+    }
+    async *itemsStream(request = {}) {
+        const pageSize = normalizePageSize(request.pageSize, request.limit);
+        const maxPages = normalizeMaxPages(request.maxPages);
+        const offset = normalizeOffset(request.offset);
+        for (let page = 0; page < maxPages; page += 1) {
+            const response = await this.items({
+                ...request,
+                limit: pageSize,
+                offset: offset + page * pageSize,
+            });
+            const pageFeatures = extractOgcFeatures(response);
+            if (pageFeatures.length === 0) {
+                break;
+            }
+            yield pageFeatures;
+            if (pageFeatures.length < pageSize) {
+                break;
+            }
+        }
+    }
+    async item(request) {
+        return this.client.getOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async createItem(request) {
+        return this.client.createOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async replaceItem(request) {
+        return this.client.replaceOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async patchItem(request) {
+        return this.client.patchOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+    async deleteItem(request) {
+        return this.client.deleteOgcItem({
+            ...request,
+            collectionId: this.collectionId,
+        });
+    }
+}
+export function createHonuaService(client, serviceId) {
+    return new HonuaService({
+        client,
+        serviceId,
+    });
+}
+export function createHonuaOgcFeatures(client) {
+    return new HonuaOgcFeatures({
+        client,
+    });
+}
+/**
+ * Wrapper over a Honua ImageServer endpoint. Each operation maps to the
+ * server route published in
+ * `honua-server/docs/gis/image-server-matrix.md`. The wrapper does not
+ * downgrade to a generic raw call: it carries a typed request shape so
+ * the contract layer can negotiate capabilities and the server can
+ * branch on a stable method name.
+ */
+export class HonuaImageService {
+    client;
+    serviceId;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+    }
+    async metadata() {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}/ImageServer`,
+            responseFormat: "json",
+        });
+    }
+    async queryRasterCatalog(request = {}) {
+        return this.dispatch("query", request, imageQueryParams(request));
+    }
+    async queryRasterCatalogObjectIds(request = {}) {
+        const response = await this.dispatch("query", request, {
+            ...imageQueryParams(request),
+            where: request.where ?? "1=1",
+            returnIdsOnly: true,
+        });
+        if (!Array.isArray(response.objectIds))
+            return [];
+        return response.objectIds.map((v) => Number(v)).filter((v) => Number.isFinite(v));
+    }
+    async exportImage(request) {
+        return this.dispatch("exportImage", request, imageExportParams(request));
+    }
+    async identify(request) {
+        return this.dispatch("identify", request, imageIdentifyParams(request));
+    }
+    /**
+     * Dispatch an ImageServer operation. POST mode sends params as a
+     * form-encoded body so the server's `TryReadRequestValuesAsync` parser
+     * finds them (returns "Request body is required" otherwise); GET mode
+     * keeps params in the query string. Both encodings are accepted by
+     * Honua Server per its ImageServer endpoint registration.
+     */
+    async dispatch(op, request, params) {
+        const method = request.method ?? "GET";
+        const path = `/rest/services/${encodeURIComponent(this.serviceId)}/ImageServer/${op}`;
+        const responseFormat = request.responseFormat ?? "json";
+        if (method === "GET") {
+            return this.client.request({ method: "GET", path, responseFormat, query: params, signal: request.signal });
+        }
+        return this.client.request({
+            method: "POST",
+            path,
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: toFormBody({ f: responseFormat, ...params }),
+            signal: request.signal,
+        });
+    }
+    tileUrl(level, row, col, format = "png") {
+        const path = `/rest/services/${encodeURIComponent(this.serviceId)}/ImageServer/tile/${level}/${row}/${col}`;
+        return `${this.client.serverBaseUrl}${path}?f=${format}`;
+    }
+    async legend() {
+        return this.client.request({
+            method: "GET",
+            path: `/rest/services/${encodeURIComponent(this.serviceId)}/ImageServer/legend`,
+            responseFormat: "json",
+        });
+    }
+}
+function imageQueryParams(request) {
+    const params = {};
+    if (request.where !== undefined)
+        params.where = request.where;
+    if (request.outFields !== undefined) {
+        params.outFields = Array.isArray(request.outFields) ? request.outFields.join(",") : String(request.outFields);
+    }
+    if (request.objectIds !== undefined) {
+        params.objectIds = Array.isArray(request.objectIds) ? request.objectIds.join(",") : String(request.objectIds);
+    }
+    if (request.returnGeometry !== undefined)
+        params.returnGeometry = request.returnGeometry;
+    if (request.outSr !== undefined)
+        params.outSR = String(request.outSr);
+    if (request.resultOffset !== undefined)
+        params.resultOffset = request.resultOffset;
+    if (request.resultRecordCount !== undefined)
+        params.resultRecordCount = request.resultRecordCount;
+    if (request.geometry !== undefined)
+        params.geometry = JSON.stringify(request.geometry);
+    if (request.geometryType !== undefined)
+        params.geometryType = String(request.geometryType);
+    if (request.spatialRel !== undefined)
+        params.spatialRel = String(request.spatialRel);
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function imageExportParams(request) {
+    const params = {};
+    if (request.bbox !== undefined) {
+        params.bbox = Array.isArray(request.bbox) ? request.bbox.join(",") : request.bbox;
+    }
+    if (request.size !== undefined) {
+        params.size = Array.isArray(request.size) ? request.size.join(",") : request.size;
+    }
+    if (request.format !== undefined)
+        params.format = request.format;
+    if (request.pixelType !== undefined)
+        params.pixelType = request.pixelType;
+    if (request.noData !== undefined)
+        params.noData = request.noData;
+    if (request.interpolation !== undefined)
+        params.interpolation = request.interpolation;
+    if (request.compressionQuality !== undefined)
+        params.compressionQuality = request.compressionQuality;
+    if (request.bandIds !== undefined) {
+        params.bandIds = Array.isArray(request.bandIds) ? request.bandIds.join(",") : String(request.bandIds);
+    }
+    if (request.mosaicRule !== undefined) {
+        params.mosaicRule =
+            typeof request.mosaicRule === "string" ? request.mosaicRule : JSON.stringify(request.mosaicRule);
+    }
+    if (request.renderingRule !== undefined) {
+        params.renderingRule =
+            typeof request.renderingRule === "string" ? request.renderingRule : JSON.stringify(request.renderingRule);
+    }
+    if (request.imageSr !== undefined)
+        params.imageSR = String(request.imageSr);
+    if (request.bboxSr !== undefined)
+        params.bboxSR = String(request.bboxSr);
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function imageIdentifyParams(request) {
+    const params = {};
+    params.geometry = typeof request.geometry === "string" ? request.geometry : JSON.stringify(request.geometry);
+    if (request.geometryType !== undefined)
+        params.geometryType = request.geometryType;
+    if (request.sr !== undefined)
+        params.sr = String(request.sr);
+    if (request.mosaicRule !== undefined) {
+        params.mosaicRule =
+            typeof request.mosaicRule === "string" ? request.mosaicRule : JSON.stringify(request.mosaicRule);
+    }
+    if (request.renderingRule !== undefined) {
+        params.renderingRule =
+            typeof request.renderingRule === "string" ? request.renderingRule : JSON.stringify(request.renderingRule);
+    }
+    if (request.pixelSize !== undefined) {
+        params.pixelSize = Array.isArray(request.pixelSize) ? request.pixelSize.join(",") : request.pixelSize;
+    }
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+/**
+ * Wrapper over a Honua Geometry Service endpoint. Routes match the
+ * canonical paths published by Honua Server's `EndpointRegistry`
+ * (`/rest/services/Utilities/Geometry/GeometryServer/<op>`; see
+ * `honua-server/docs/gis/geometry-service-matrix.md`). Wraps the
+ * server-supported operations: `project`, `buffer`, `simplify`,
+ * `intersect`, `union`, `clip`, `difference`. Operations not
+ * implemented in Honua Server (autoComplete, convexHull, cut,
+ * areasAndLengths/lengths measurement helpers, etc.) intentionally have
+ * no wrapper — callers that need them go through the raw `request()`
+ * escape hatch and handle 404s themselves.
+ *
+ * POST mode submits form-encoded bodies so the server's
+ * `TryReadRequestValuesAsync` parser finds the parameters. GET mode keeps
+ * params in the query string (the server accepts both).
+ */
+const GEOMETRY_SERVICE_ROOT = "/rest/services/Utilities/Geometry/GeometryServer";
+export class HonuaGeometryService {
+    client;
+    constructor(options) {
+        this.client = options.client;
+    }
+    async project(request) {
+        return this.dispatch("project", request, geometryProjectParams(request));
+    }
+    async buffer(request) {
+        return this.dispatch("buffer", request, geometryBufferParams(request));
+    }
+    async simplify(request) {
+        return this.dispatch("simplify", request, geometrySimplifyParams(request));
+    }
+    async intersect(request) {
+        return this.dispatch("intersect", request, geometryBinaryParams(request));
+    }
+    async union(request) {
+        return this.dispatch("union", request, geometryUnionParams(request));
+    }
+    async clip(request) {
+        return this.dispatch("clip", request, geometryBinaryParams(request));
+    }
+    async difference(request) {
+        return this.dispatch("difference", request, geometryBinaryParams(request));
+    }
+    async dispatch(op, request, params) {
+        const method = request.method ?? "POST";
+        const path = `${GEOMETRY_SERVICE_ROOT}/${op}`;
+        const responseFormat = request.responseFormat ?? "json";
+        if (method === "GET") {
+            return this.client.request({ method: "GET", path, responseFormat, query: params, signal: request.signal });
+        }
+        return this.client.request({
+            method: "POST",
+            path,
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body: toFormBody({ f: responseFormat, ...params }),
+            signal: request.signal,
+        });
+    }
+}
+function geometryProjectParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        inSR: typeof request.inSr === "string" || typeof request.inSr === "number"
+            ? String(request.inSr)
+            : JSON.stringify(request.inSr),
+        outSR: typeof request.outSr === "string" || typeof request.outSr === "number"
+            ? String(request.outSr)
+            : JSON.stringify(request.outSr),
+    };
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometryBufferParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        distances: Array.isArray(request.distances) ? request.distances.join(",") : String(request.distances),
+    };
+    if (request.unit !== undefined)
+        params.unit = request.unit;
+    if (request.inSr !== undefined)
+        params.inSR = typeof request.inSr === "object" ? JSON.stringify(request.inSr) : String(request.inSr);
+    if (request.outSr !== undefined)
+        params.outSR = typeof request.outSr === "object" ? JSON.stringify(request.outSr) : String(request.outSr);
+    if (request.bufferSr !== undefined)
+        params.bufferSR =
+            typeof request.bufferSr === "object" ? JSON.stringify(request.bufferSr) : String(request.bufferSr);
+    if (request.unionResults !== undefined)
+        params.unionResults = request.unionResults;
+    if (request.geodesic !== undefined)
+        params.geodesic = request.geodesic;
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometrySimplifyParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+    };
+    if (request.sr !== undefined)
+        params.sr = typeof request.sr === "object" ? JSON.stringify(request.sr) : String(request.sr);
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometryBinaryParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        geometry: typeof request.geometry === "string" ? request.geometry : JSON.stringify(request.geometry),
+        sr: typeof request.sr === "object" ? JSON.stringify(request.sr) : String(request.sr),
+    };
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function geometryUnionParams(request) {
+    const params = {
+        geometries: typeof request.geometries === "string" ? request.geometries : JSON.stringify(request.geometries),
+        sr: typeof request.sr === "object" ? JSON.stringify(request.sr) : String(request.sr),
+    };
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+/**
+ * Wrapper over a Honua GP Service task. Mirrors the routes published in
+ * `honua-server/docs/gis/geoprocess-framework-analysis.md`: `submitJob`,
+ * `jobs/{jobId}` (status), `jobs/{jobId}/cancel`, and per-result lookup
+ * (currently registered route, output delivery still depends on the
+ * execution engine — see the parity matrix).
+ */
+export class HonuaGeoprocessingService {
+    client;
+    serviceId;
+    taskName;
+    constructor(options) {
+        this.client = options.client;
+        this.serviceId = options.serviceId;
+        this.taskName = options.taskName;
+    }
+    async submitJob(request) {
+        return this.client.request({
+            method: request.method ?? "POST",
+            path: this.taskPath("submitJob"),
+            responseFormat: request.responseFormat ?? "json",
+            query: gpSubmitParams(request),
+            signal: request.signal,
+        });
+    }
+    async jobStatus(jobId, options = {}) {
+        return this.client.request({
+            method: "GET",
+            path: `${this.taskPath("jobs")}/${encodeURIComponent(jobId)}`,
+            responseFormat: "json",
+            signal: options.signal,
+        });
+    }
+    async cancelJob(jobId, options = {}) {
+        return this.client.request({
+            method: "POST",
+            path: `${this.taskPath("jobs")}/${encodeURIComponent(jobId)}/cancel`,
+            responseFormat: "json",
+            signal: options.signal,
+        });
+    }
+    async jobResult(jobId, resultName, options = {}) {
+        return this.client.request({
+            method: "GET",
+            path: `${this.taskPath("jobs")}/${encodeURIComponent(jobId)}/results/${encodeURIComponent(resultName)}`,
+            responseFormat: "json",
+            signal: options.signal,
+        });
+    }
+    taskPath(suffix) {
+        const taskSegment = this.taskName ? `/${encodeURIComponent(this.taskName)}` : "";
+        return `/rest/services/${encodeURIComponent(this.serviceId)}/GPServer${taskSegment}/${suffix}`;
+    }
+}
+function gpSubmitParams(request) {
+    const params = {};
+    for (const [key, value] of Object.entries(request.parameters)) {
+        params[key] =
+            typeof value === "string" || typeof value === "number" || typeof value === "boolean"
+                ? value
+                : JSON.stringify(value);
+    }
+    Object.assign(params, request.extraParams ?? {});
+    return params;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFiniteNumber(value) {
+    return typeof value === "number" && Number.isFinite(value);
+}
+function extractFeatureCountFromResponse(response) {
+    if (isObject(response) && typeof response.count === "number" && Number.isFinite(response.count)) {
+        return response.count;
+    }
+    if (isObject(response) && Array.isArray(response.features)) {
+        return response.features.length;
+    }
+    return 0;
+}
+function extractFeaturesFromResponse(response) {
+    if (!isObject(response) || !Array.isArray(response.features)) {
+        return [];
+    }
+    return response.features;
+}
+function extractObjectIdsFromResponse(response) {
+    if (!isObject(response) || !Array.isArray(response.objectIds)) {
+        return [];
+    }
+    return response.objectIds.map((value) => Number(value)).filter((value) => Number.isFinite(value));
+}
+function extractExtentFromResponse(response) {
+    if (!isObject(response)) {
+        return { extent: null };
+    }
+    const count = isFiniteNumber(response.count) ? response.count : undefined;
+    const extent = isObject(response.extent) ? response.extent : null;
+    return { extent, count };
+}
+function normalizeObjectIds(ids) {
+    return Array.isArray(ids) ? ids.join(",") : String(ids);
+}
+function toFormBody(values) {
+    const params = new URLSearchParams();
+    for (const [key, value] of Object.entries(values)) {
+        params.set(key, String(value));
+    }
+    return params.toString();
+}
+function normalizeLayerPath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+}
+function normalizeServicePath(path) {
+    return path.startsWith("/") ? path.slice(1) : path;
+}
+function normalizePageSize(pageSize, limit) {
+    if (isFinitePositiveInteger(pageSize)) {
+        return pageSize;
+    }
+    if (isFinitePositiveInteger(limit)) {
+        return limit;
+    }
+    return 100;
+}
+function normalizeMaxPages(maxPages) {
+    if (isFinitePositiveInteger(maxPages)) {
+        return maxPages;
+    }
+    return 100;
+}
+function normalizeOffset(offset) {
+    if (typeof offset !== "number" || !Number.isFinite(offset)) {
+        return 0;
+    }
+    return Math.max(0, Math.trunc(offset));
+}
+function normalizeTotalLimit(limit) {
+    if (!isFinitePositiveInteger(limit)) {
+        return undefined;
+    }
+    return limit;
+}
+function isFinitePositiveInteger(value) {
+    return typeof value === "number" && Number.isFinite(value) && Math.trunc(value) > 0;
+}
+function buildAttachmentFormData(request) {
+    const form = new FormData();
+    if (request.attachment instanceof Blob) {
+        const blob = ensureBlobType(request.attachment, request.contentType);
+        const fileName = request.name ?? resolveBlobName(request.attachment);
+        form.set("attachment", blob, fileName);
+        return form;
+    }
+    const blob = new Blob([request.attachment], {
+        type: request.contentType ?? "application/octet-stream",
+    });
+    form.set("attachment", blob, request.name ?? "attachment.txt");
+    return form;
+}
+function resolveBlobName(blob) {
+    if ("name" in blob && typeof blob.name === "string" && blob.name.length > 0) {
+        return blob.name;
+    }
+    return "attachment.bin";
+}
+function ensureBlobType(blob, contentType) {
+    if (!contentType || blob.type === contentType) {
+        return blob;
+    }
+    return new Blob([blob], { type: contentType });
+}
+function extractLayerIds(metadata) {
+    if (!isObject(metadata) || !Array.isArray(metadata.layers)) {
+        return [];
+    }
+    const ids = [];
+    for (const layer of metadata.layers) {
+        if (!isObject(layer)) {
+            continue;
+        }
+        const parsed = Number(layer.id);
+        if (!Number.isFinite(parsed)) {
+            continue;
+        }
+        ids.push(Math.trunc(parsed));
+    }
+    return ids;
+}
+function extractOgcFeatures(response) {
+    if (!isObject(response) || !Array.isArray(response.features)) {
+        return [];
+    }
+    return response.features;
+}