@urban-toolkit/autk-db 2.0.0

package/dist/src/spatial/use-cases/assign-building-ids/AssignBuildingIdsUseCase.d.ts

@@ -0,0 +1,21 @@
+import { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { Column } from '../../../shared/interfaces';
+/**
+ * Assigns stable `building_id` values by clustering intersecting building geometries.
+ */
+export declare class AssignBuildingIdsUseCase {
+    private db;
+    private conn;
+    constructor(db: AsyncDuckDB, conn: AsyncDuckDBConnection);
+    /**
+     * Reads geometries from the provided building table, computes intersecting
+     * clusters in JS, writes a stable building_id per row back to the table, and
+     * returns the updated column list for the table.
+     */
+    exec(params: {
+        tableName: string;
+        workspace?: string;
+    }): Promise<Column[]>;
+    private columnExists;
+    private describeColumns;
+}

package/dist/src/spatial/use-cases/build-heatmap/BuildHeatmapUseCase.d.ts

@@ -0,0 +1,14 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { BuildHeatmapParams } from './interfaces';
+import { BoundingBox, Table } from '../../../shared/interfaces';
+/**
+ * Builds a heatmap grid by spatially joining source data into grid cells.
+ */
+export declare class BuildHeatmapUseCase {
+    private conn;
+    private loadGridLayerUseCase;
+    private spatialJoinUseCase;
+    constructor(conn: AsyncDuckDBConnection);
+    exec(params: BuildHeatmapParams, tables: Array<Table>, boundingBox?: BoundingBox): Promise<Table>;
+    private transformToRasterFormat;
+}

package/dist/src/spatial/use-cases/build-heatmap/index.d.ts

@@ -0,0 +1,2 @@
+export { BuildHeatmapUseCase } from './BuildHeatmapUseCase';
+export type { BuildHeatmapParams } from './interfaces';

package/dist/src/spatial/use-cases/build-heatmap/interfaces.d.ts

@@ -0,0 +1,18 @@
+export type HeatmapAggregateFunction = 'sum' | 'avg' | 'count' | 'min' | 'max' | 'weighted';
+export interface BuildHeatmapParams {
+    tableJoinName: string;
+    nearDistance: number;
+    outputTableName: string;
+    groupBy?: {
+        selectColumns: Array<{
+            tableName: string;
+            column: string;
+            aggregateFn?: HeatmapAggregateFunction;
+            aggregateFnResultColumnName?: string;
+        }>;
+    };
+    grid: {
+        rows: number;
+        columns: number;
+    };
+}

package/dist/src/spatial/use-cases/get-layer-geojson/GetLayerGeojsonUseCase.d.ts

@@ -0,0 +1,11 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { FeatureCollection } from 'geojson';
+import { CustomLayerTable, LayerTable } from '../../../shared/interfaces';
+/**
+ * Exports a layer table as a GeoJSON FeatureCollection.
+ */
+export declare class GetLayerGeojsonUseCase {
+    private conn;
+    constructor(conn: AsyncDuckDBConnection);
+    exec(table: LayerTable | CustomLayerTable, workspace?: string): Promise<FeatureCollection>;
+}

package/dist/src/spatial/use-cases/get-layer-geojson/index.d.ts

@@ -0,0 +1 @@
+export * from './GetLayerGeojsonUseCase';

package/dist/src/spatial/use-cases/get-layer-geojson/queries.d.ts

@@ -0,0 +1,2 @@
+import { CustomLayerTable, LayerTable } from '../../../shared/interfaces';
+export declare const GET_LAYER_AS_GEOJSON_QUERY: (layerTable: LayerTable | CustomLayerTable, workspace: string) => string;

package/dist/src/spatial/use-cases/get-table-data/GetTableDataUseCase.d.ts

@@ -0,0 +1,10 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { GetTableDataParams, GetTableDataOutput } from './interfaces';
+/**
+ * Reads rows from any table as plain JavaScript objects.
+ */
+export declare class GetTableDataUseCase {
+    private conn;
+    constructor(conn: AsyncDuckDBConnection);
+    exec(params: GetTableDataParams): Promise<GetTableDataOutput>;
+}

package/dist/src/spatial/use-cases/get-table-data/index.d.ts

@@ -0,0 +1,2 @@
+export { GetTableDataUseCase } from './GetTableDataUseCase';
+export type { GetTableDataParams, GetTableDataOutput } from './interfaces';

package/dist/src/spatial/use-cases/get-table-data/interfaces.d.ts

@@ -0,0 +1,7 @@
+export interface GetTableDataParams {
+    tableName: string;
+    limit?: number;
+    offset?: number;
+    workspace?: string;
+}
+export type GetTableDataOutput = Record<string, unknown>[];

package/dist/src/spatial/use-cases/load-csv/LoadCsvUseCase.d.ts

@@ -0,0 +1,13 @@
+import { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { LoadCsvParams } from './interfaces';
+import { CsvTable } from '../../../shared/interfaces';
+/**
+ * Loads CSV data into DuckDB, with optional geometry column creation.
+ */
+export declare class LoadCsvUseCase {
+    private db;
+    private conn;
+    constructor(db: AsyncDuckDB, conn: AsyncDuckDBConnection);
+    exec({ csvFileUrl, csvObject, outputTableName, geometryColumns, delimiter, workspace }: LoadCsvParams): Promise<CsvTable>;
+    private buildCsvString;
+}

package/dist/src/spatial/use-cases/load-csv/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoadCsvUseCase';
+export type { LoadCsvParams } from './interfaces';

package/dist/src/spatial/use-cases/load-csv/interfaces.d.ts

@@ -0,0 +1,12 @@
+export interface LoadCsvParams {
+    csvFileUrl?: string;
+    csvObject?: unknown[][];
+    outputTableName: string;
+    delimiter?: string;
+    geometryColumns?: {
+        latColumnName: string;
+        longColumnName: string;
+        coordinateFormat?: string;
+    };
+    workspace?: string;
+}

package/dist/src/spatial/use-cases/load-csv/queries.d.ts

@@ -0,0 +1,12 @@
+export declare const LOAD_CSV_ON_TABLE_QUERY: (csvFileUrl: string, tableName: string, delimiter: string, workspace: string) => string;
+interface LoadCsvOnTableWithCoordinatesParams {
+    csvFileUrl: string;
+    tableName: string;
+    delimiter: string;
+    latColumnName: string;
+    longColumnName: string;
+    coordinateFormat: string;
+    workspace: string;
+}
+export declare const LOAD_CSV_ON_TABLE_WITH_COORDINATES_QUERY: ({ csvFileUrl, tableName, delimiter, latColumnName, longColumnName, coordinateFormat, workspace, }: LoadCsvOnTableWithCoordinatesParams) => string;
+export {};

package/dist/src/spatial/use-cases/load-custom-layer/LoadCustomLayerUseCase.d.ts

@@ -0,0 +1,13 @@
+import { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { CustomLayerTable } from '../../../shared/interfaces';
+import { LoadCustomLayerParams } from './interfaces';
+/**
+ * Loads a GeoJSON FeatureCollection as a spatial layer table.
+ */
+export declare class LoadCustomLayerUseCase {
+    private db;
+    private conn;
+    constructor(db: AsyncDuckDB, conn: AsyncDuckDBConnection);
+    exec({ geojsonFileUrl, geojsonObject, outputTableName, coordinateFormat, boundingBox, workspace, layerType, }: LoadCustomLayerParams): Promise<CustomLayerTable>;
+    private createTableFromFeatureCollection;
+}

package/dist/src/spatial/use-cases/load-custom-layer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoadCustomLayerUseCase';
+export type { LoadCustomLayerParams } from './interfaces';

package/dist/src/spatial/use-cases/load-custom-layer/interfaces.d.ts

@@ -0,0 +1,13 @@
+import { FeatureCollection } from 'geojson';
+import { LayerType } from 'autk-core';
+import { BoundingBox } from '../../../shared/interfaces';
+export interface LoadCustomLayerParams {
+    geojsonFileUrl?: string;
+    geojsonObject?: FeatureCollection;
+    outputTableName: string;
+    coordinateFormat?: string;
+    boundingBox?: BoundingBox;
+    workspace?: string;
+    /** Explicitly set the layer type. If omitted, auto-detected from the first feature's geometry. */
+    layerType?: LayerType;
+}

package/dist/src/spatial/use-cases/load-custom-layer/queries.d.ts

@@ -0,0 +1,3 @@
+import { BoundingBox } from '../../../shared/interfaces';
+export declare const LOAD_FEATURE_COLLECTION_QUERY: (geojsonFileUrl: string, featureCollectionTableName: string, workspace: string) => string;
+export declare const LOAD_LAYER_FROM_FEATURE_COLLECTION_QUERY: (featureCollectionTableName: string, outputTableName: string, coordinateFormat: string, workspace: string, boundingBox?: BoundingBox) => string;

package/dist/src/spatial/use-cases/load-geotiff/LoadGeoTiffUseCase.d.ts

@@ -0,0 +1,12 @@
+import { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { GeoTiffTable } from '../../../shared/interfaces';
+import { LoadGeoTiffParams } from './interfaces';
+/**
+ * Loads a GeoTIFF raster file into DuckDB as a spatially-indexed table.
+ */
+export declare class LoadGeoTiffUseCase {
+    private db;
+    private conn;
+    constructor(db: AsyncDuckDB, conn: AsyncDuckDBConnection);
+    exec(params: LoadGeoTiffParams): Promise<GeoTiffTable>;
+}

package/dist/src/spatial/use-cases/load-geotiff/index.d.ts

@@ -0,0 +1,2 @@
+export { LoadGeoTiffUseCase } from './LoadGeoTiffUseCase';
+export type { LoadGeoTiffParams } from './interfaces';

package/dist/src/spatial/use-cases/load-geotiff/interfaces.d.ts

@@ -0,0 +1,33 @@
+import { BoundingBox } from '../../../shared/interfaces';
+export interface LoadGeoTiffParams {
+    /** URL of the GeoTIFF file to fetch and load. */
+    geotiffFileUrl?: string;
+    /** Raw ArrayBuffer of an already-fetched GeoTIFF file. */
+    geotiffArrayBuffer?: ArrayBuffer;
+    /** Name of the output DuckDB table. */
+    outputTableName: string;
+    /**
+     * Target coordinate format for the geometry column (e.g. 'EPSG:3395').
+     * Defaults to EPSG:4326 (no transformation).
+     */
+    coordinateFormat?: string;
+    /**
+     * CRS of the input GeoTIFF (e.g. 'EPSG:4326', 'EPSG:32633').
+     * Required when coordinateFormat differs from the file's native CRS.
+     * If omitted, no coordinate transformation is applied.
+     */
+    sourceCrs?: string;
+    /**
+     * Clip the raster to this bounding box (in the source CRS) before loading.
+     * Strongly recommended for large tiles — without it the full raster is decoded,
+     * which may be millions of pixels and exceed browser memory limits.
+     */
+    boundingBox?: BoundingBox;
+    /**
+     * Maximum number of pixels to load. Defaults to 500 000.
+     * An error is thrown if the decoded region exceeds this limit,
+     * prompting the caller to supply a `boundingBox` to reduce the area.
+     */
+    maxPixels?: number;
+    workspace?: string;
+}

package/dist/src/spatial/use-cases/load-grid-layer/LoadGridLayerUseCase.d.ts

@@ -0,0 +1,17 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { BoundingBox, GridLayerTable } from '../../../shared/interfaces';
+export interface LoadGridLayerParams {
+    boundingBox?: BoundingBox;
+    rows: number;
+    columns: number;
+    outputTableName: string;
+    workspace?: string;
+}
+/**
+ * Creates a grid layer table with evenly spaced cell centroids.
+ */
+export declare class LoadGridLayerUseCase {
+    private conn;
+    constructor(conn: AsyncDuckDBConnection);
+    exec(params: LoadGridLayerParams): Promise<GridLayerTable>;
+}

package/dist/src/spatial/use-cases/load-json/LoadJsonUseCase.d.ts

@@ -0,0 +1,12 @@
+import { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { LoadJsonParams } from './interfaces';
+import { JsonTable } from '../../../shared/interfaces';
+/**
+ * Loads JSON data into DuckDB, with optional geometry column creation.
+ */
+export declare class LoadJsonUseCase {
+    private db;
+    private conn;
+    constructor(db: AsyncDuckDB, conn: AsyncDuckDBConnection);
+    exec({ jsonFileUrl, jsonObject, outputTableName, geometryColumns, workspace }: LoadJsonParams): Promise<JsonTable>;
+}

package/dist/src/spatial/use-cases/load-json/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoadJsonUseCase';
+export type { LoadJsonParams } from './interfaces';

package/dist/src/spatial/use-cases/load-json/interfaces.d.ts

@@ -0,0 +1,11 @@
+export interface LoadJsonParams {
+    jsonFileUrl?: string;
+    jsonObject?: unknown[];
+    outputTableName: string;
+    geometryColumns?: {
+        latColumnName: string;
+        longColumnName: string;
+        coordinateFormat?: string;
+    };
+    workspace?: string;
+}

package/dist/src/spatial/use-cases/load-json/queries.d.ts

@@ -0,0 +1,11 @@
+export declare const LOAD_JSON_ON_TABLE_QUERY: (jsonFileUrl: string, tableName: string, workspace: string) => string;
+interface LoadJsonOnTableWithCoordinatesParams {
+    jsonFileUrl: string;
+    tableName: string;
+    latColumnName: string;
+    longColumnName: string;
+    coordinateFormat: string;
+    workspace: string;
+}
+export declare const LOAD_JSON_ON_TABLE_WITH_COORDINATES_QUERY: ({ jsonFileUrl, tableName, latColumnName, longColumnName, coordinateFormat, workspace, }: LoadJsonOnTableWithCoordinatesParams) => string;
+export {};

package/dist/src/spatial/use-cases/load-layer/LoadLayerUseCase.d.ts

@@ -0,0 +1,27 @@
+import { AsyncDuckDB, AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { LoadLayerParams } from './interfaces';
+import { LayerTable } from '../../../shared/interfaces';
+/**
+ * Extracts a thematic layer (roads, buildings, parks, water, surface) from raw OSM data.
+ */
+export declare class LoadLayerUseCase {
+    private db;
+    private conn;
+    private assignBuildingIdsUseCase;
+    private aggregateBuildingLayerUseCase;
+    constructor(db: AsyncDuckDB, conn: AsyncDuckDBConnection);
+    exec(params: LoadLayerParams): Promise<LayerTable>;
+    private appendRelationAreaGeometries;
+    private buildRelationAreaRecords;
+    private buildRelationGeometry;
+    private buildClosedRings;
+    private stitchOpenWaySegmentsIntoRings;
+    private tryMergeRings;
+    private concatRings;
+    private reverseRing;
+    private ringContainsPosition;
+    private parseTags;
+    private toNumberArray;
+    private toStringArray;
+    private toNumber;
+}

package/dist/src/spatial/use-cases/load-layer/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoadLayerUseCase';
+export type { LoadLayerParams, Layer } from './interfaces';

package/dist/src/spatial/use-cases/load-layer/interfaces.d.ts

@@ -0,0 +1,19 @@
+import { LayerType, BoundingBox } from 'autk-core';
+export type { LayerType };
+export interface LoadLayerParams {
+    osmInputTableName: string;
+    outputTableName?: string;
+    layer: LayerType;
+    coordinateFormat?: string;
+    boundingBox?: BoundingBox;
+    workspace?: string;
+}
+export interface Layer {
+    metadata: {
+        [key: string]: string;
+    };
+    linestring: {
+        type: 'LineString';
+        coordinates: Array<Array<number>>;
+    };
+}

package/dist/src/spatial/use-cases/load-layer/osm-processing-config.d.ts

@@ -0,0 +1,10 @@
+import { LayerType } from 'autk-core';
+export type OsmLayerType = Exclude<LayerType, 'background'>;
+export interface OsmProcessingConfig {
+    type: OsmLayerType;
+    processesRelations: boolean;
+    createsPolygons: boolean;
+    postProcessing?: 'building-aggregation' | 'surface-polygonization' | null;
+}
+export declare const OSM_PROCESSING_CONFIGS: Record<OsmLayerType, OsmProcessingConfig>;
+export declare function getOsmProcessingConfig(layer: LayerType): OsmProcessingConfig | null;

package/dist/src/spatial/use-cases/load-layer/queries.d.ts

@@ -0,0 +1,12 @@
+import { LayerType } from './interfaces';
+import { BoundingBox } from '../../../shared/interfaces';
+type Params = {
+    tableName: string;
+    layer: LayerType;
+    outputFormat: string;
+    outputTableName: string;
+    boundingBox?: BoundingBox;
+    workspace?: string;
+};
+export declare const LOAD_LAYER_QUERY: ({ tableName, layer, outputFormat, outputTableName, boundingBox, workspace }: Params) => string;
+export {};

package/dist/src/spatial/use-cases/load-osm-from-overpass-api/LoadOsmFromOverpassApiUseCase.d.ts

@@ -0,0 +1,89 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { LoadOsmParams } from './interfaces';
+import { OsmTable } from '../../../shared/interfaces';
+import { OsmProcessingPipeline } from '../osm-processing-pipeline/OsmProcessingPipeline';
+interface OsmExecResult {
+    tables: OsmTable[];
+    osmElementCount: number;
+    boundaryElementCount: number;
+    osmDataProcessingMs: number;
+    boundariesProcessingMs: number;
+}
+/**
+ * Loads OSM data from the Overpass API with caching, retry, and slot polling.
+ */
+export declare class LoadOsmFromOverpassApiUseCase {
+    private readonly conn;
+    private readonly cache;
+    private readonly pipeline;
+    constructor(conn: AsyncDuckDBConnection, pipeline: OsmProcessingPipeline);
+    exec(params: LoadOsmParams): Promise<OsmExecResult>;
+    private getCacheKey;
+    private getFullDataCacheKey;
+    /**
+     * Fetches OSM data as four independent requests — boundaries, parks+water,
+     * roads, buildings — so each request is smaller and less likely to trigger a
+     * 504. A pause between requests avoids immediate rate-limiting. Results are
+     * cached for 24h.
+     *
+     * `geocodeArea` (e.g. "New York") is used only as a disambiguation scope.
+     * All data is spatially constrained to the entries in `queryArea.areas`.
+     */
+    private fetchCombinedOsmData;
+    private static readonly OVERPASS_ENDPOINT;
+    private static readonly OVERPASS_STATUS_ENDPOINT;
+    private static readonly QUERY_TIMEOUTS_S;
+    private static setQueryTimeout;
+    /**
+     * Polls the Overpass status endpoint until a slot is free, then returns.
+     * Fails silently — a status check error never blocks the actual request.
+     */
+    private waitForSlot;
+    /**
+     * POSTs a query to the Overpass API with slot checking and automatic retry.
+     *
+     * POST is used so large queries are never truncated by proxy URL-length limits.
+     * Before each top-level call the slot status is checked and waited on.
+     *
+     * Retryable conditions:
+     *  - 429 / 503 — server overloaded; backoff: 20s → 45s → 90s → 120s → 180s → 240s
+     *  - 504 / ERR_EMPTY_RESPONSE / fetch timeout — proxy rejection; backoff:
+     *    10s → 20s → 45s → 90s → 120s → 180s, plus [timeout] in the query is
+     *    stepped down (60s → 45s → 30s → 20s → 15s → 10s) so each retry looks
+     *    cheaper to the server.
+     *
+     * All backoff values have ±10% jitter. The fetch-level AbortController
+     * deadline is derived from the current query [timeout] + 30s overhead.
+     */
+    private fetchWithRetry;
+    /**
+     * Builds the boundaries query: admin relations + their member ways.
+     * Relations are output with `body` only (tags + member IDs); ways get full
+     * inline geometry via `out geom qt`.
+     */
+    private buildBoundariesQuery;
+    /**
+     * Builds a query for a specific group of layers.
+     * Returns null when no tag selectors apply to the given group (e.g. surface-only).
+     */
+    private buildLayerGroupQuery;
+    /**
+     * Returns Overpass tag filter expressions for the requested layers.
+     * Uses value-level specificity for `natural` to avoid fetching unused types
+     * (coastline, beach, cliff, etc.). `surface` needs no selectors — its ways
+     * come from `way(r.rel)` in the boundaries query.
+     */
+    private getTagSelectorsForLayers;
+    private buildExactValueSelector;
+    private buildExcludedValueSelector;
+    /**
+     * Returns `cols × rows` Overpass queries that together cover `bbox`, each
+     * using a combined area + tile-bbox filter so only features inside both the
+     * named OSM area and the tile are returned.  256 MB maxsize per tile keeps
+     * each response well within Overpass limits.
+     */
+    private buildBuildingsTileQueries;
+    /** Merges two Overpass responses, deduplicating all elements by (type, id). */
+    private mergeResponses;
+}
+export {};

package/dist/src/spatial/use-cases/load-osm-from-overpass-api/index.d.ts

@@ -0,0 +1,2 @@
+export * from './LoadOsmFromOverpassApiUseCase';
+export type { LoadOsmParams, LoadingPhase, OnLoadingProgress, OsmLoadTimings, LayerLoadTimings } from './interfaces';

package/dist/src/spatial/use-cases/load-osm-from-overpass-api/interfaces.d.ts

@@ -0,0 +1,59 @@
+import { LayerType } from 'autk-core';
+export interface OsmElement {
+    type: 'node' | 'way' | 'relation';
+    id: number;
+    lat?: number;
+    lon?: number;
+    tags?: Record<string, string>;
+    members?: {
+        type: 'node' | 'way' | 'relation';
+        ref: number;
+        role?: string;
+    }[];
+    nodes?: number[];
+    /** Inline geometry from Overpass `out geom;` — present alongside `nodes` for ways. */
+    geometry?: Array<{
+        lat: number;
+        lon: number;
+    }>;
+}
+export type LoadingPhase = 'querying-osm-server' | 'downloading-osm-data' | 'processing-osm-data' | 'processing-boundaries';
+export type OnLoadingProgress = (phase: LoadingPhase) => void;
+export interface LayerLoadTimings {
+    layerName: string;
+    layerType: string;
+    /** Time in ms to run the SQL query that extracts this layer from the OSM table (excludes HTTP). */
+    loadMs: number;
+    /** Number of GeoJSON features in the loaded layer. */
+    featureCount: number;
+}
+export interface OsmLoadTimings {
+    /** Number of OSM elements (nodes + ways + relations) in the main dataset. */
+    osmElementCount: number;
+    /** Number of elements in the boundary dataset. */
+    boundaryElementCount: number;
+    /** Time in ms to insert OSM elements into DuckDB (excludes HTTP download). */
+    osmDataProcessingMs: number;
+    /** Time in ms to insert boundary elements into DuckDB (excludes HTTP download). */
+    boundariesProcessingMs: number;
+    /** Per-layer timing and feature count details (populated when autoLoadLayers is used). */
+    layers: LayerLoadTimings[];
+}
+export type LoadOsmParams = {
+    outputTableName: string;
+    autoLoadLayers?: {
+        coordinateFormat: string;
+        dropOsmTable: boolean;
+        layers: Array<LayerType>;
+    };
+    queryArea: {
+        geocodeArea: string;
+        areas: string[];
+    };
+    /** If provided, OSM data is loaded from this `.osm.pbf` file instead of the Overpass API. */
+    pbfFileUrl?: string;
+    /** When true, bypasses the cached Overpass response and fetches fresh data. */
+    forceRefresh?: boolean;
+    workspace?: string;
+    onProgress?: OnLoadingProgress;
+};

package/dist/src/spatial/use-cases/load-osm-from-overpass-api/queries.d.ts

@@ -0,0 +1,2 @@
+export declare const CREATE_OSM_TABLE_QUERY: (tableName: string, workspace: string) => string;
+export declare const INSERT_OSM_DATA_QUERY: (tableName: string, fileName: string, workspace: string, ignoreTags?: boolean) => string;

package/dist/src/spatial/use-cases/load-osm-from-pbf/LoadOsmFromPbfUseCase.d.ts

@@ -0,0 +1,39 @@
+import { AsyncDuckDBConnection } from '@duckdb/duckdb-wasm';
+import { OsmTable } from '../../../shared/interfaces';
+import { LoadOsmParams } from '../load-osm-from-overpass-api/interfaces';
+import { OsmProcessingPipeline } from '../osm-processing-pipeline/OsmProcessingPipeline';
+interface OsmExecResult {
+    tables: OsmTable[];
+    osmElementCount: number;
+    boundaryElementCount: number;
+    osmDataProcessingMs: number;
+    boundariesProcessingMs: number;
+}
+/**
+ * Loads OSM data from a local PBF file with multi-pass streaming.
+ */
+export declare class LoadOsmFromPbfUseCase {
+    private readonly conn;
+    private readonly pipeline;
+    constructor(conn: AsyncDuckDBConnection, pipeline: OsmProcessingPipeline);
+    exec(params: LoadOsmParams): Promise<OsmExecResult>;
+    private getRequestedLayers;
+    private collectBoundaryContext;
+    private collectBoundaryBbox;
+    private collectCandidateWaysAndRelations;
+    private collectRequiredNodes;
+    private filterFinalElements;
+    private buildGroupedCollections;
+    private mergeResponses;
+    private getRelationWayRefs;
+    private wayIntersectsBbox;
+    private streamPbfBlocks;
+    private matchesRequestedWayLayers;
+    private matchesRequestedRelationLayers;
+    private isRoadTagSet;
+    private isBuildingTagSet;
+    private isParkTagSet;
+    private isWaterTagSet;
+    private hasTagValue;
+}
+export {};

package/dist/src/spatial/use-cases/load-osm-from-pbf/index.d.ts

@@ -0,0 +1 @@
+export { LoadOsmFromPbfUseCase } from './LoadOsmFromPbfUseCase';

package/dist/src/spatial/use-cases/load-osm-from-pbf/osm-pbf-parser.d.ts

@@ -0,0 +1,28 @@
+import { OsmPbfBlock } from '@osmix/pbf';
+import { OsmElement } from '../load-osm-from-overpass-api/interfaces';
+/**
+ * Converts a `@osmix/pbf` block into an array of `OsmElement` records.
+ *
+ * Handles all four primitive types:
+ * - regular nodes
+ * - dense nodes (delta-encoded, compact storage)
+ * - ways (with node refs)
+ * - relations (with member refs)
+ *
+ * StringTable indices are resolved to actual tag strings.
+ * Way geometry is **not** resolved here — caller must build a node index
+ * and call `resolveWayGeometries()` afterwards.
+ */
+export declare function blockToElements(block: OsmPbfBlock): OsmElement[];
+/**
+ * Resolves inline `geometry` for every way by looking up node coordinates.
+ *
+ * Mutates the `elements` array in place — each way that has a non-empty
+ * `nodes[]` array gets a matching `geometry[]` array.
+ *
+ * @returns A `Map<nodeId, {lat, lon}>` for downstream use (e.g. bbox computation).
+ */
+export declare function resolveWayGeometries(elements: OsmElement[]): Map<number, {
+    lat: number;
+    lon: number;
+}>;