@loaders.gl/arcgis 5.0.0-alpha.10

package/src/arcgis/arcgis-scene-server-source-loader.ts

@@ -0,0 +1,216 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ArcGISAuthentication} from '../authentication';
+import {ARCGIS_SCENE_SERVER_SOURCE_LOADER_METADATA} from '../arcgis-source-types';
+import type {
+  ArcGISSceneQueryOptions,
+  ArcGISSceneQueryResult,
+  ArcGISSceneServerSourceOptions
+} from '../arcgis-source-types';
+
+import type {CoreAPI, DataSourceOptions, SourceLoader} from '@loaders.gl/loader-utils';
+import {DataSource} from '@loaders.gl/loader-utils';
+import {
+  createI3SLayerSource,
+  normalizeI3SServiceMetadata,
+  parseI3SSceneLayerMetadata
+} from '@loaders.gl/i3s';
+import type {I3SLayerSource, I3SServiceMetadata, SceneLayer3D} from '@loaders.gl/i3s';
+import {buildArcGISResourceURL} from './arcgis-url-utils';
+
+/** Error raised when a SceneServer query cannot be completed or decoded. */
+export class ArcGISSceneServerQueryError extends Error {
+  /** HTTP status code, when the failure came from a response. */
+  readonly status?: number;
+
+  /** Creates a typed SceneServer query error. */
+  constructor(message: string, status?: number) {
+    super(message);
+    this.name = 'ArcGISSceneServerQueryError';
+    this.status = status;
+  }
+}
+
+/** Source facade for an ArcGIS SceneServer I3S layer. */
+export class ArcGISSceneServerSource extends DataSource<string, ArcGISSceneServerSourceOptions> {
+  /** Cached normalized layer metadata. */
+  private metadataPromise: Promise<I3SServiceMetadata> | null = null;
+  /** Cached profile-specific tileset source. */
+  private sourcePromise: Promise<I3SLayerSource> | null = null;
+
+  /** Creates a SceneServer source. */
+  constructor(url: string, options: ArcGISSceneServerSourceOptions = {}, coreApi?: CoreAPI) {
+    super(
+      trimTrailingSlashes(url),
+      options,
+      ARCGIS_SCENE_SERVER_SOURCE_LOADER_METADATA.defaultOptions,
+      coreApi
+    );
+  }
+
+  /** Returns normalized SceneServer layer metadata. */
+  async getMetadata(): Promise<I3SServiceMetadata> {
+    this.metadataPromise ||= this.loadMetadata();
+    return await this.metadataPromise;
+  }
+
+  /** Creates the existing mesh or Point Cloud source for this layer. */
+  async getTilesetSource(): Promise<I3SLayerSource> {
+    this.sourcePromise ||= this.createTilesetSource();
+    return await this.sourcePromise;
+  }
+
+  /** Queries feature attributes and geometry from a SceneServer layer. */
+  async query(options: ArcGISSceneQueryOptions = {}): Promise<ArcGISSceneQueryResult> {
+    const {signal, f = 'json', ...queryParameters} = options;
+    const queryURL = buildArcGISResourceURL(this.getLayerURL(), 'query', {
+      where: '1=1',
+      outFields: '*',
+      returnGeometry: true,
+      f,
+      ...queryParameters,
+      token: this.getToken()
+    });
+    const response = await this.fetch(queryURL, signal ? {signal} : undefined);
+    if (!response.ok) {
+      throw new ArcGISSceneServerQueryError(
+        `ArcGIS SceneServer query failed: ${response.status} ${response.statusText}`,
+        response.status
+      );
+    }
+    const document = (await response.json()) as Record<string, unknown>;
+    if (document.error) {
+      throw new ArcGISSceneServerQueryError(
+        `ArcGIS SceneServer query returned an error: ${JSON.stringify(document.error)}`
+      );
+    }
+    return {
+      features: Array.isArray(document.features) ? document.features : [],
+      fields: Array.isArray(document.fields) ? document.fields : undefined,
+      exceededTransferLimit:
+        typeof document.exceededTransferLimit === 'boolean'
+          ? document.exceededTransferLimit
+          : undefined,
+      rawMetadata: document
+    };
+  }
+
+  /** Alias for query used by applications that consume generic feature sources. */
+  async getFeatures(options: ArcGISSceneQueryOptions = {}): Promise<ArcGISSceneQueryResult> {
+    return await this.query(options);
+  }
+
+  /** Returns the layer URL, resolving an explicit layer ID when needed. */
+  getLayerURL(): string {
+    const url = new URL(this.url);
+    url.pathname = trimTrailingSlashes(url.pathname);
+    if (/\/SceneServer\/layers\/[^/]+$/i.test(url.pathname)) {
+      url.search = '';
+      url.hash = '';
+      return url.toString();
+    }
+
+    if (!/\/SceneServer$/i.test(url.pathname)) {
+      throw new Error(
+        'ArcGISSceneServerSource requires a /SceneServer/layers/{id} URL or a /SceneServer URL with arcgis-scene-server.layerId'
+      );
+    }
+
+    const layerId = this.options['arcgis-scene-server']?.layerId;
+    if (layerId === undefined) {
+      throw new Error(
+        'ArcGISSceneServerSource requires a /SceneServer/layers/{id} URL or a /SceneServer URL with arcgis-scene-server.layerId'
+      );
+    }
+    url.pathname = `${url.pathname.replace(/\/$/, '')}/layers/${encodeURIComponent(String(layerId))}`;
+    url.search = '';
+    url.hash = '';
+    return url.toString();
+  }
+
+  /** Returns the metadata request URL with ArcGIS JSON and authentication parameters. */
+  metadataURL(): string {
+    const url = new URL(this.getLayerURL());
+    url.searchParams.set('f', 'pjson');
+    const token = this.getToken();
+    if (token && !url.searchParams.has('token')) {
+      url.searchParams.set('token', token);
+    }
+    return url.toString();
+  }
+
+  private async loadMetadata(): Promise<I3SServiceMetadata> {
+    const configuredMetadata = this.options['arcgis-scene-server']?.metadata;
+    const layer = configuredMetadata
+      ? parseI3SSceneLayerMetadata(configuredMetadata)
+      : await this.fetchLayerMetadata();
+    return normalizeI3SServiceMetadata(this.getLayerURL(), layer);
+  }
+
+  private async fetchLayerMetadata(): Promise<SceneLayer3D> {
+    const response = await this.fetch(this.metadataURL());
+    if (!response.ok) {
+      throw new Error(
+        `ArcGIS SceneServer metadata request failed: ${response.status} ${response.statusText}`
+      );
+    }
+    return parseI3SSceneLayerMetadata(await response.json());
+  }
+
+  private async createTilesetSource(): Promise<I3SLayerSource> {
+    const metadata = await this.getMetadata();
+    return createI3SLayerSource(
+      metadata.url,
+      metadata.layer,
+      this.getSourceOptions(),
+      this.coreApi
+    );
+  }
+
+  private getSourceOptions(): DataSourceOptions {
+    const i3sOptions = (this.options['i3s'] as Record<string, unknown> | undefined) || {};
+    const token = this.getToken();
+    return {
+      ...this.options,
+      i3s: token ? {...i3sOptions, token} : i3sOptions
+    };
+  }
+
+  private getToken(): string | undefined {
+    const serviceToken = this.options['arcgis-scene-server']?.token;
+    const i3sToken = (this.options['i3s'] as Record<string, unknown> | undefined)?.token;
+    if (serviceToken) {
+      return serviceToken;
+    }
+    if (typeof i3sToken === 'string' && i3sToken) {
+      return i3sToken;
+    }
+    return new URL(this.url).searchParams.get('token') || undefined;
+  }
+}
+
+/** Runtime service loader for synchronous construction. */
+export const ArcGISSceneServerSourceLoaderWithParser = {
+  ...ARCGIS_SCENE_SERVER_SOURCE_LOADER_METADATA,
+  dataType: null as unknown as ArcGISSceneServerSource,
+  batchType: null as never,
+  preload: undefined,
+  /** Supplies ArcGIS credentials after loading the selected implementation. */
+  getAuthentications: () => [ArcGISAuthentication],
+  createDataSource: (
+    url: string,
+    options: ArcGISSceneServerSourceOptions = {},
+    coreApi?: CoreAPI
+  ) => new ArcGISSceneServerSource(url, options, coreApi)
+} as const satisfies SourceLoader<ArcGISSceneServerSource>;
+
+/** Removes trailing URL separators in linear time, including for untrusted service URLs. */
+function trimTrailingSlashes(value: string): string {
+  let endIndex = value.length;
+  while (endIndex > 0 && value[endIndex - 1] === '/') {
+    endIndex--;
+  }
+  return value.slice(0, endIndex);
+}

package/src/arcgis/arcgis-server.ts

@@ -0,0 +1,61 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+export type Service = {name: string; type: string; url: string};
+
+type FetchLike = typeof fetch;
+
+/**
+ * (Recursively) load the service directory from an ArcGIS Server URL
+ * @param url
+ * @param fetchFile= Optional fetch function override
+ * @returns
+ */
+export async function getArcGISServices(
+  url: string,
+  fetchFile: FetchLike = fetch
+): Promise<Service[] | null> {
+  if (url.includes('rest/services')) {
+    const serverUrl = url.replace(/rest\/services.*$/i, 'rest/services');
+    return loadServiceDirectory(serverUrl, fetchFile, []);
+  }
+  return null;
+}
+
+async function loadServiceDirectory(
+  serverUrl: string,
+  fetch: FetchLike,
+  path: string[]
+): Promise<Service[]> {
+  const serviceUrl = path.length ? `${serverUrl}/${path.join('/')}` : serverUrl;
+
+  const response = await fetch(`${serviceUrl}?f=pjson`);
+  const directory = await response.json();
+
+  const services = extractServices(directory, serviceUrl, serverUrl);
+
+  const folders = (directory.folders || []) as string[];
+  const promises = folders.map(folder =>
+    loadServiceDirectory(`${serverUrl}`, fetch, [...path, folder])
+  );
+
+  for (const folderServices of await Promise.all(promises)) {
+    services.push(...folderServices);
+  }
+
+  return services;
+}
+
+function extractServices(directory: unknown, url: string, serverUrl: string): Service[] {
+  const arcgisServices = ((directory as any).services || []) as {name: string; type: string}[];
+  const services: Service[] = [];
+  for (const service of arcgisServices) {
+    services.push({
+      name: service.name,
+      type: `arcgis-${service.type.toLocaleLowerCase().replace('server', '-server')}`,
+      url: `${service.name.includes('/') ? serverUrl : url}/${service.name}/${service.type}`
+    });
+  }
+  return services;
+}

package/src/arcgis/arcgis-url-utils.ts

@@ -0,0 +1,26 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/** Builds an ArcGIS REST resource URL while preserving authentication query parameters. */
+export function buildArcGISResourceURL(
+  serviceURL: string,
+  resourcePath: string,
+  parameters: Record<string, unknown>
+): string {
+  const url = new URL(serviceURL);
+  if (resourcePath) {
+    url.pathname = `${url.pathname.replace(/\/$/, '')}/${resourcePath.replace(/^\//, '')}`;
+  }
+  for (const [key, value] of Object.entries(parameters)) {
+    if (value === undefined || value === null) continue;
+    url.searchParams.set(key, encodeArcGISParameter(value));
+  }
+  return url.toString();
+}
+
+/** Converts a generic request value to ArcGIS REST query syntax. */
+function encodeArcGISParameter(value: unknown): string {
+  if (Array.isArray(value)) return value.join(',');
+  return typeof value === 'object' ? JSON.stringify(value) : String(value);
+}

package/src/arcgis/arcgis-vector-tile-server-source-loader-types.ts

@@ -0,0 +1,36 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ARCGIS_VECTOR_TILE_SERVER_SOURCE_LOADER_METADATA} from '../arcgis-source-types';
+import type {CoreAPI, SourceLoader} from '@loaders.gl/loader-utils';
+import type {ArcGISVectorTileServerSource} from './arcgis-vector-tile-server-source-loader';
+import type {ArcGISVectorTileServerSourceLoaderOptions} from '../arcgis-source-types';
+
+/** Loads the ArcGISVectorTileServerSourceLoader implementation on first asynchronous use. */
+async function preloadArcGISVectorTileServerSourceLoader(): Promise<
+  SourceLoader<ArcGISVectorTileServerSource>
+> {
+  const {ArcGISVectorTileServerSourceLoaderWithParser} = await import(
+    '@loaders.gl/arcgis/arcgis-vector-tile-server-source-loader'
+  );
+  return ArcGISVectorTileServerSourceLoaderWithParser;
+}
+
+/** Lightweight service descriptor; use load() or the synchronous /bundled entrypoint. */
+export const ArcGISVectorTileServerSourceLoader = {
+  ...ARCGIS_VECTOR_TILE_SERVER_SOURCE_LOADER_METADATA,
+  dataType: null as unknown as ArcGISVectorTileServerSource,
+  batchType: null as never,
+  preload: preloadArcGISVectorTileServerSourceLoader,
+  /** Requires the runtime loader when constructing a source synchronously. */
+  createDataSource(
+    _url: string,
+    _options: ArcGISVectorTileServerSourceLoaderOptions,
+    _coreApi?: CoreAPI
+  ): ArcGISVectorTileServerSource {
+    throw new Error(
+      'ArcGISVectorTileServerSourceLoader requires async load() or an @loaders.gl/arcgis/bundled import'
+    );
+  }
+} as const satisfies SourceLoader<ArcGISVectorTileServerSource>;

package/src/arcgis/arcgis-vector-tile-server-source-loader.ts

@@ -0,0 +1,196 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import {ArcGISAuthentication} from '../authentication';
+import {ARCGIS_VECTOR_TILE_SERVER_SOURCE_LOADER_METADATA} from '../arcgis-source-types';
+import type {
+  ArcGISVectorTileServiceMetadata,
+  ArcGISVectorTileServerSourceLoaderOptions
+} from '../arcgis-source-types';
+
+import type {
+  CoreAPI,
+  GetTileDataParameters,
+  GetTileParameters,
+  SourceLoader,
+  TileSourceMetadata,
+  VectorTile,
+  VectorTileSource
+} from '@loaders.gl/loader-utils';
+import {DataSource} from '@loaders.gl/loader-utils';
+import {MVTLoader, type MVTLoaderOptions} from '@loaders.gl/mvt';
+import type {Schema} from '@loaders.gl/schema';
+
+/** A source for ArcGIS VectorTileServer metadata and PBF tiles. */
+export class ArcGISVectorTileServerSource
+  extends DataSource<string, ArcGISVectorTileServerSourceLoaderOptions>
+  implements VectorTileSource
+{
+  /** Decoded tile family consumed by generic tile renderers. */
+  readonly mimeType = 'application/vnd.mapbox-vector-tile';
+  /** ArcGIS tiles are decoded to WGS84 coordinates before rendering. */
+  readonly localCoordinates = false;
+  /** Cached service metadata request. */
+  private serviceMetadata: Promise<ArcGISVectorTileServiceMetadata> | null = null;
+  /** Query parameters supplied with the service URL, such as an access token. */
+  private readonly serviceQueryParameters: URLSearchParams;
+
+  /** Creates an ArcGIS VectorTileServer source. */
+  constructor(
+    url: string,
+    options: ArcGISVectorTileServerSourceLoaderOptions = {},
+    coreApi?: CoreAPI
+  ) {
+    const serviceURL = new URL(url);
+    serviceURL.pathname = serviceURL.pathname.replace(/\/$/, '');
+    super(
+      `${serviceURL.origin}${serviceURL.pathname}`,
+      options,
+      ARCGIS_VECTOR_TILE_SERVER_SOURCE_LOADER_METADATA.defaultOptions,
+      coreApi
+    );
+    this.serviceQueryParameters = new URLSearchParams(serviceURL.search);
+  }
+
+  /** Returns normalized service and tile-grid metadata. */
+  async getMetadata(): Promise<TileSourceMetadata> {
+    const metadata = await this.getServiceMetadata();
+    const tileInfo = metadata.tileInfo;
+    const lods = tileInfo?.lods || [];
+    const extent = metadata.fullExtent || metadata.initialExtent;
+    return {
+      name: metadata.mapName || this.url.split('/').pop() || '',
+      title: metadata.mapName,
+      abstract: metadata.serviceDescription,
+      format: 'application/vnd.mapbox-vector-tile',
+      minZoom: lods[0]?.level,
+      maxZoom: lods.at(-1)?.level,
+      boundingBox: extent
+        ? [
+            [extent.xmin, extent.ymin],
+            [extent.xmax, extent.ymax]
+          ]
+        : undefined,
+      layer: {
+        name: metadata.mapName || '',
+        srs: tileInfo?.spatialReference ? [getSpatialReference(tileInfo.spatialReference)] : [],
+        layers: []
+      },
+      formatHeader: {
+        tileInfo,
+        styleURL: this.getStyleURL(),
+        spriteURL: this.getSpriteURL()
+      }
+    };
+  }
+
+  /** Fetches one raw PBF tile from the ArcGIS tile endpoint. */
+  async getTile(parameters: GetTileParameters, signal?: AbortSignal): Promise<ArrayBuffer | null> {
+    const response = await this.fetch(this.getTileURL(parameters), {
+      signal,
+      headers: {Accept: 'application/vnd.mapbox-vector-tile, application/x-protobuf'}
+    });
+    if (!response.ok) return null;
+    return response.arrayBuffer();
+  }
+
+  /** Returns the schema advertised by decoded vector tiles. */
+  async getSchema(): Promise<Schema> {
+    return {fields: [], metadata: {}};
+  }
+
+  /** Fetches and decodes one ArcGIS vector tile to geographic coordinates. */
+  async getVectorTile(parameters: GetTileParameters): Promise<VectorTile | null> {
+    const arrayBuffer = await this.getTile(parameters, parameters.signal);
+    if (!arrayBuffer) {
+      return null;
+    }
+    const inheritedOptions = (this.loadOptions as MVTLoaderOptions).mvt;
+    const sourceOptions = this.options['arcgis-vector-tile-server']?.mvt;
+    return (await this.coreApi.parse(arrayBuffer, MVTLoader, {
+      ...this.loadOptions,
+      mvt: {
+        ...inheritedOptions,
+        ...sourceOptions,
+        coordinates: 'wgs84',
+        tileIndex: {x: parameters.x, y: parameters.y, z: parameters.z},
+        layers:
+          normalizeLayers(parameters.layers) || sourceOptions?.layers || inheritedOptions?.layers
+      }
+    })) as VectorTile;
+  }
+
+  /** Provides decoded vector tiles through the deck.gl source interface. */
+  async getTileData(parameters: GetTileDataParameters): Promise<VectorTile | null> {
+    return this.getVectorTile({...parameters.index, signal: parameters.signal});
+  }
+
+  /** Builds the ArcGIS cached vector tile URL. */
+  getTileURL(parameters: GetTileParameters): string {
+    return this.getResourceURL(`/tile/${parameters.z}/${parameters.y}/${parameters.x}.pbf`);
+  }
+
+  /** Returns the service metadata URL. */
+  getMetadataURL(): string {
+    const url = new URL(this.getResourceURL(''));
+    url.searchParams.set('f', 'pjson');
+    return url.toString();
+  }
+
+  /** Returns the ArcGIS Mapbox style resource URL. */
+  getStyleURL(): string {
+    return this.getResourceURL('/resources/styles/root.json');
+  }
+
+  /** Returns the ArcGIS sprite resource base URL. */
+  getSpriteURL(): string {
+    return this.getResourceURL('/resources/sprites/sprite');
+  }
+
+  /** Loads and caches the ArcGIS VectorTileServer metadata document. */
+  private async getServiceMetadata(): Promise<ArcGISVectorTileServiceMetadata> {
+    this.serviceMetadata ||= this.fetch(this.getMetadataURL()).then(async response => {
+      if (!response.ok)
+        throw new Error(`ArcGIS VectorTileServer request failed: ${response.status}`);
+      return (await response.json()) as ArcGISVectorTileServiceMetadata;
+    });
+    return this.serviceMetadata;
+  }
+
+  /** Builds a resource URL while retaining service query parameters. */
+  private getResourceURL(resourcePath: string): string {
+    const url = new URL(this.url);
+    url.pathname = `${url.pathname.replace(/\/$/, '')}${resourcePath}`;
+    for (const [key, value] of this.serviceQueryParameters) {
+      url.searchParams.set(key, value);
+    }
+    return url.toString();
+  }
+}
+
+/** Runtime service loader for synchronous construction. */
+export const ArcGISVectorTileServerSourceLoaderWithParser = {
+  ...ARCGIS_VECTOR_TILE_SERVER_SOURCE_LOADER_METADATA,
+  dataType: null as unknown as ArcGISVectorTileServerSource,
+  batchType: null as never,
+  preload: undefined,
+  /** Supplies ArcGIS credentials after loading the selected implementation. */
+  getAuthentications: () => [ArcGISAuthentication],
+  createDataSource: (
+    url: string,
+    options: ArcGISVectorTileServerSourceLoaderOptions = {},
+    coreApi?: CoreAPI
+  ) => new ArcGISVectorTileServerSource(url, options, coreApi)
+} as const satisfies SourceLoader<ArcGISVectorTileServerSource>;
+
+/** Converts an ArcGIS spatial reference to an EPSG identifier. */
+function getSpatialReference(spatialReference: {wkid?: number; latestWkid?: number}): string {
+  return `EPSG:${spatialReference.latestWkid || spatialReference.wkid}`;
+}
+
+/** Normalizes generic tile layer selection for the MVT parser. */
+function normalizeLayers(layers?: string | string[]): string[] | undefined {
+  if (!layers) return undefined;
+  return Array.isArray(layers) ? layers : [layers];
+}

package/src/arcgis-feature-query-types.ts

@@ -0,0 +1,89 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GeoJSONTable} from '@loaders.gl/schema';
+import type {GetFeaturesParameters} from '@loaders.gl/loader-utils';
+import type {ArcGISFeatureServiceQueryOptions} from './arcgis-source-types';
+
+/** Parameters shared by feature, table and MapServer layer queries. */
+export type ArcGISFeatureQueryParameters = Partial<GetFeaturesParameters> & {
+  /** Per-request filters, overriding source query defaults. */
+  query?: ArcGISFeatureServiceQueryOptions;
+};
+
+/** Controls bounded retrieval of a complete query. */
+export type ArcGISFeatureQueryOptions = ArcGISFeatureQueryParameters & {
+  /** Maximum records per page, capped by the advertised service limit. Default 1000. */
+  pageSize?: number;
+  /** Maximum retained records. Default 100000; reaching it can produce an incomplete result. */
+  maxFeatures?: number;
+  /** Concurrent object-ID batches, between 1 and 8. Default 4; offset pages are serial. */
+  concurrency?: number;
+  /** Auto uses ordered pagination when advertised, otherwise object-ID batches. */
+  strategy?: 'auto' | 'offset' | 'object-ids';
+  /** Reports each yielded page, including the final completion assessment. */
+  onProgress?: (progress: ArcGISFeatureQueryProgress) => void;
+};
+
+/** Completion evidence for the selected query, never a transactional snapshot guarantee. */
+export type ArcGISFeatureQueryProgress = {
+  /** Number of unique records retained so far. */
+  loaded: number;
+  /** Count observed before retrieval; absent for a single-page request. */
+  expectedCount?: number;
+  /** Number of data pages processed. */
+  pages: number;
+  /** Duplicate records discarded while retrieving pages. */
+  duplicates: number;
+  /** True only after traversal finishes and its unique count matches the initial server count. */
+  complete: boolean;
+  /** Whether the query includes a viewport bounding box. */
+  scope: 'viewport' | 'query';
+  /** Retrieval strategy used for this result. */
+  strategy: 'offset' | 'object-ids' | 'page';
+  /** Why retrieval is in progress, finished, or incomplete. */
+  reason:
+    | 'loading'
+    | 'complete'
+    | 'single-page'
+    | 'feature-limit'
+    | 'id-limit'
+    | 'count-mismatch'
+    | 'no-progress';
+};
+
+/** One page with cumulative progress, or the collected result of queryFeatures(). */
+export type ArcGISFeatureQueryResult = ArcGISFeatureQueryProgress & {
+  /** Spatial features or table records represented as features with null geometry. */
+  data: GeoJSONTable;
+};
+
+/** Result of an IDs-only request; this alone does not prove query completeness. */
+export type ArcGISFeatureObjectIds = {
+  /** Stable object ID field advertised by the response. */
+  objectIdFieldName: string;
+  /** Unique safe-integer or string identifiers returned by the service. */
+  objectIds: (number | string)[];
+  /** True when the service explicitly reports truncated identifiers. */
+  exceededTransferLimit: boolean;
+};
+
+/** Extent-only response, retaining the service's explicit spatial reference. */
+export type ArcGISFeatureExtent = {
+  /** Matching record count when supplied by the server. */
+  count?: number;
+  /** Null for an empty or nonspatial query. */
+  extent: {
+    /** Minimum x coordinate. */
+    xmin: number;
+    /** Minimum y coordinate. */
+    ymin: number;
+    /** Maximum x coordinate. */
+    xmax: number;
+    /** Maximum y coordinate. */
+    ymax: number;
+    /** Coordinate reference of the returned bounds. */
+    spatialReference: {wkid?: number; latestWkid?: number; wkt?: string};
+  } | null;
+};