@osmix/pbf 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @osmix/pbf
+
+## 0.0.1
+
+### Patch Changes
+
+- Initial release

package/README.md

@@ -0,0 +1,144 @@
+# @osmix/pbf
+
+@osmix/pbf is a low-level TypeScript toolkit for reading and writing OpenStreetMap PBF data. It keeps the API surface close to the official protobuf schema, surfaces predictable types, and runs in Node 20+ and modern browsers through Web Streams and native compression primitives.
+
+## Highlights
+
+- Parse headers and primitive blocks from `ArrayBufferLike`, async iterables, or Web `ReadableStream`s.
+- Build streaming pipelines with `TransformStream` helpers instead of buffering entire files in memory.
+- Serialize header and primitive blocks back to spec-compliant blobs with size guardrails baked in.
+- Reuse generated protobuf types/readers so downstream tools can stay close to `osmformat.proto`.
+- Utility helpers handle compression, concatenation, and big-endian encoding tuned for the PBF format.
+
+## Installation
+
+```sh
+npm install @osmix/pbf
+```
+
+## Usage
+
+### Read an entire file
+
+`readOsmPbf` accepts an `ArrayBufferLike`, async iterable, or Web `ReadableStream`. It returns the header block and an async generator of primitive blocks.
+
+```ts
+import { readOsmPbf } from "@osmix/pbf"
+
+const response = await fetch("/fixtures/monaco.pbf")
+const { header, blocks } = await readOsmPbf(response.body)
+
+console.log(header.required_features)
+
+for await (const block of blocks) {
+	for (const group of block.primitivegroup) {
+		console.log(group.nodes?.length, group.ways.length, group.relations.length)
+	}
+}
+```
+
+### Stream as you go
+
+Use the streaming helpers when you do not want to materialize the whole file.
+
+```ts
+import { OsmPbfBytesToBlocksTransformStream } from "@osmix/pbf"
+
+const response = await fetch("/fixtures/monaco.pbf")
+
+await response.body
+	.pipeThrough(new OsmPbfBytesToBlocksTransformStream())
+	.pipeTo(
+		new WritableStream({
+			write: (block) => {
+				if ("primitivegroup" in block) {
+					// Handle primitive data blocks.
+					return
+				}
+
+				console.log("Header bbox", block.bbox)
+			},
+		}),
+	)
+```
+
+### Write blocks back to PBF
+
+Serialize individual blocks into blobs, or stream them directly to a writable target.
+
+#### Buffer the result
+
+```ts
+import { concatUint8, osmBlockToPbfBlobBytes, readOsmPbf } from "@osmix/pbf"
+
+const response = await fetch("/fixtures/monaco.pbf")
+const { header, blocks } = await readOsmPbf(response.body)
+
+const chunks: Uint8Array[] = [await osmBlockToPbfBlobBytes(header)]
+for await (const block of blocks) chunks.push(await osmBlockToPbfBlobBytes(block))
+
+const fullFile = concatUint8(...chunks)
+
+```
+
+#### Stream to a sink
+
+Generators returned by `readOsmPbf` are single-use. Re-open the source (or buffer the blocks) if you want to stream the same dataset again.
+
+```ts
+import { OsmBlocksToPbfBytesTransformStream, readOsmPbf } from "@osmix/pbf"
+
+const response = await fetch("/fixtures/monaco.pbf")
+const { header, blocks } = await readOsmPbf(response.body)
+
+const upstream = new ReadableStream({
+	async start(controller) {
+		controller.enqueue(header)
+		for await (const block of blocks) controller.enqueue(block)
+		controller.close()
+	},
+})
+
+await upstream
+	.pipeThrough(new OsmBlocksToPbfBytesTransformStream())
+	.pipeTo(new WritableStream({ write: persistChunk }))
+```
+
+`persistChunk` represents your storage layer (filesystem writes, uploads, IndexedDB, and so on). It receives `Uint8Array` pieces in the order they should be persisted.
+
+## API overview
+
+- `readOsmPbf(data)` – Parses binary PBF data, returning `{ header, blocks }`. Throws if the first block is not an OSM header.
+- `OsmPbfBytesToBlocksTransformStream` – Web `TransformStream` that emits the header once and then primitive blocks as they become available.
+- `OsmBlocksToPbfBytesTransformStream` – Inverse transform that turns header/primitive blocks into PBF byte blobs while enforcing size limits.
+- `createOsmPbfBlobGenerator()` – Returns a stateful generator that slices incoming bytes into compressed blob payloads (`Uint8Array`s), emitting the header blob first.
+- `osmPbfBlobsToBlocksGenerator(blobs)` – Accepts a (async) generator of compressed blobs, decompresses them, and yields the header followed by primitive blocks.
+- `osmBlockToPbfBlobBytes(block)` – Serializes a single header or primitive block, returning the BlobHeader length prefix and blob bytes as one `Uint8Array`.
+- Utility exports: `toAsyncGenerator`, `compress`, `decompress`, `concatUint8`, `uint32BE`, and the size constants from `spec.ts`. Compression helpers detect Bun and fall back to Node's zlib bindings for compatibility.
+- Generated protobuf helpers: `readHeaderBlock`, `writeHeaderBlock`, `readPrimitiveBlock`, `writePrimitiveBlock`, plus the associated TypeScript types (`OsmPbfBlock`, `OsmPbfHeaderBlock`, `OsmPbfBlob`, and friends).
+
+## See also
+
+- [`@osmix/json`](../json/README.md) – Converts parsed blocks into ergonomic JSON or GeoJSON entities.
+- [`@osmix/core`](../core/README.md) – Uses these readers/writers for ingest and export workflows.
+- [`@osmix/change`](../change/README.md) – Builds on `@osmix/core` to generate change pipelines.
+
+## Environment and limitations
+
+- Requires runtimes with Web Streams + `CompressionStream` / `DecompressionStream` support (modern browsers, Node 20+).
+- Only `zlib_data` blobs are supported today; files containing `raw` or `lzma` payloads will throw.
+- When working with Node `Readable` / `Writable` streams, adapt them to Web Streams (`stream/web`) before passing them to these helpers.
+
+### Memory usage guidance
+
+- Prefer streaming transforms (`OsmPbfBytesToBlocksTransformStream` → `OsmBlocksToPbfBytesTransformStream`) for large extracts to avoid materializing entire files.
+- Re-materializing full files (e.g., concatenating all blocks into one buffer) can require memory roughly proportional to input size plus transient compression buffers.
+- In browsers, keep an eye on available heap limits (2–4 GB typical). Use chunked persistence (IndexedDB, file streams) rather than holding all bytes in RAM.
+
+## Development
+
+- `bun run test packages/pbf`
+- `bun run lint packages/pbf`
+- `bun run typecheck packages/pbf`
+
+Run `bun run check` at the repo root before publishing to ensure formatting, lint, and type coverage.

package/dist/blobs-to-blocks.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Decompresses raw OSM PBF blobs and yields typed header and primitive blocks.
+ * Expects the first blob to contain the file header and streams the rest as data blocks.
+ */
+export declare function osmPbfBlobsToBlocksGenerator(blobs: AsyncGenerator<Uint8Array<ArrayBuffer>> | Generator<Uint8Array<ArrayBuffer>>): AsyncGenerator<import(".").OsmPbfHeaderBlock | import(".").OsmPbfBlock, void, unknown>;

package/dist/blobs-to-blocks.js

@@ -0,0 +1,21 @@
+import Pbf from "pbf";
+import { readHeaderBlock, readPrimitiveBlock } from "./proto/osmformat";
+import { decompress } from "./utils";
+/**
+ * Decompresses raw OSM PBF blobs and yields typed header and primitive blocks.
+ * Expects the first blob to contain the file header and streams the rest as data blocks.
+ */
+export async function* osmPbfBlobsToBlocksGenerator(blobs) {
+    let headerRead = false;
+    for await (const blob of blobs) {
+        const decompressedBlob = await decompress(blob);
+        const pbf = new Pbf(decompressedBlob);
+        if (!headerRead) {
+            headerRead = true;
+            yield readHeaderBlock(pbf);
+        }
+        else {
+            yield readPrimitiveBlock(pbf);
+        }
+    }
+}

package/dist/blocks-to-pbf.d.ts

@@ -0,0 +1,16 @@
+import type { OsmPbfBlock, OsmPbfHeaderBlock } from "./proto/osmformat";
+/**
+ * Serializes a header or primitive block into a spec-compliant compressed blob.
+ * Automatically sets the blob type, compresses the payload, and enforces size guardrails.
+ * @param block - Parsed header or primitive block to encode.
+ * @returns BlobHeader length prefix + Blob bytes as a single Uint8Array.
+ */
+export declare function osmBlockToPbfBlobBytes(block: OsmPbfBlock | OsmPbfHeaderBlock): Promise<Uint8Array<ArrayBufferLike>>;
+/**
+ * Web `TransformStream` that converts OSM header/data blocks into PBF byte chunks.
+ * Throws if the header is not the first block and reuses `osmBlockToPbfBlobBytes` for encoding.
+ */
+export declare class OsmBlocksToPbfBytesTransformStream extends TransformStream<OsmPbfHeaderBlock | OsmPbfBlock, Uint8Array> {
+    headerEnqueued: boolean;
+    constructor();
+}

package/dist/blocks-to-pbf.js

@@ -0,0 +1,73 @@
+import Pbf from "pbf";
+import { writeBlob, writeBlobHeader } from "./proto/fileformat";
+import { writeHeaderBlock, writePrimitiveBlock } from "./proto/osmformat";
+import { MAX_BLOB_SIZE_BYTES, MAX_HEADER_SIZE_BYTES, RECOMMENDED_BLOB_SIZE_BYTES, RECOMMENDED_HEADER_SIZE_BYTES, } from "./spec";
+import { compress, concatUint8, uint32BE } from "./utils";
+/**
+ * Serializes a header or primitive block into a spec-compliant compressed blob.
+ * Automatically sets the blob type, compresses the payload, and enforces size guardrails.
+ * @param block - Parsed header or primitive block to encode.
+ * @returns BlobHeader length prefix + Blob bytes as a single Uint8Array.
+ */
+export async function osmBlockToPbfBlobBytes(block) {
+    const contentPbf = new Pbf();
+    let type;
+    if ("primitivegroup" in block) {
+        type = "OSMData";
+        writePrimitiveBlock(block, contentPbf);
+    }
+    else {
+        type = "OSMHeader";
+        writeHeaderBlock(block, contentPbf);
+    }
+    const contentData = contentPbf.finish();
+    const raw_size = contentData.length;
+    const compressedBuffer = await compress(contentData);
+    const blobPbf = new Pbf();
+    writeBlob({
+        raw_size,
+        zlib_data: compressedBuffer,
+    }, blobPbf);
+    const blob = blobPbf.finish();
+    const blobHeaderPbf = new Pbf();
+    writeBlobHeader({
+        type,
+        datasize: blob.length,
+    }, blobHeaderPbf);
+    const blobHeader = blobHeaderPbf.finish();
+    const blobHeaderSize = uint32BE(blobHeader.byteLength);
+    // Check the BlobHeader and Blob sizes, log error if over the recommended size, throw error if over the maximum size
+    if (blobHeader.byteLength > RECOMMENDED_HEADER_SIZE_BYTES) {
+        const sizeKiB = (blobHeader.byteLength / 1024).toFixed(2);
+        if (blobHeader.byteLength > MAX_HEADER_SIZE_BYTES) {
+            throw new Error(`BlobHeader is ${sizeKiB} KiB, the maximum size is 64KiB`);
+        }
+        console.warn(`BlobHeader is ${sizeKiB} KiB, the recommended size is 32KiB`);
+    }
+    if (blob.byteLength > RECOMMENDED_BLOB_SIZE_BYTES) {
+        const sizeMiB = (blob.byteLength / 1024 / 1024).toFixed(2);
+        if (blob.byteLength > MAX_BLOB_SIZE_BYTES) {
+            throw new Error(`Blob is ${sizeMiB} MiB, the maximum size is 32MiB`);
+        }
+        console.warn(`Blob is ${sizeMiB} MiB, the recommended size is 16MiB`);
+    }
+    return concatUint8(blobHeaderSize, blobHeader, blob);
+}
+/**
+ * Web `TransformStream` that converts OSM header/data blocks into PBF byte chunks.
+ * Throws if the header is not the first block and reuses `osmBlockToPbfBlobBytes` for encoding.
+ */
+export class OsmBlocksToPbfBytesTransformStream extends TransformStream {
+    headerEnqueued = false;
+    constructor() {
+        super({
+            transform: async (block, controller) => {
+                if ("primitivegroup" in block && !this.headerEnqueued) {
+                    throw Error("Header first in ReadableStream of blocks.");
+                }
+                this.headerEnqueued = true;
+                controller.enqueue(await osmBlockToPbfBlobBytes(block));
+            },
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./blobs-to-blocks";
+export * from "./blocks-to-pbf";
+export * from "./pbf-to-blobs";
+export * from "./pbf-to-blocks";
+export * from "./proto/fileformat";
+export * from "./proto/osmformat";
+export * from "./spec";
+export * from "./utils";

package/dist/index.js

@@ -0,0 +1,8 @@
+export * from "./blobs-to-blocks";
+export * from "./blocks-to-pbf";
+export * from "./pbf-to-blobs";
+export * from "./pbf-to-blocks";
+export * from "./proto/fileformat";
+export * from "./proto/osmformat";
+export * from "./spec";
+export * from "./utils";

package/dist/pbf-to-blobs.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Creates a stateful parser that slices incoming bytes into compressed OSM PBF blobs.
+ * Works with buffers, iterables, or streams and yields `Uint8Array` payloads ready to decompress.
+ * The first blob represents the file header; subsequent blobs hold primitive data.
+ */
+export declare function createOsmPbfBlobGenerator(): (chunk: Uint8Array) => Generator<Uint8Array<ArrayBuffer>, void, unknown>;

package/dist/pbf-to-blobs.js

@@ -0,0 +1,48 @@
+import Pbf from "pbf";
+import { HEADER_LENGTH_BYTES } from "./pbf-to-blocks";
+import { readBlob, readBlobHeader, } from "./proto/fileformat";
+/**
+ * Creates a stateful parser that slices incoming bytes into compressed OSM PBF blobs.
+ * Works with buffers, iterables, or streams and yields `Uint8Array` payloads ready to decompress.
+ * The first blob represents the file header; subsequent blobs hold primitive data.
+ */
+export function createOsmPbfBlobGenerator() {
+    let pbf = new Pbf(new Uint8Array(0));
+    let state = "header-length";
+    let bytesNeeded = HEADER_LENGTH_BYTES;
+    let blobHeader = null;
+    /**
+     * Feed the parser with the next chunk of bytes and yield any complete compressed blobs.
+     */
+    return function* nextChunk(chunk) {
+        const currentBuffer = pbf.buf.slice(pbf.pos);
+        const tmpBuffer = new Uint8Array(currentBuffer.buffer.byteLength + chunk.byteLength);
+        tmpBuffer.set(currentBuffer.subarray(0));
+        tmpBuffer.set(new Uint8Array(chunk), currentBuffer.byteLength);
+        pbf = new Pbf(tmpBuffer);
+        while (pbf.pos + bytesNeeded <= pbf.length) {
+            if (state === "header-length") {
+                const dataView = new DataView(pbf.buf.buffer);
+                bytesNeeded = dataView.getInt32(pbf.pos, false); // network byte order
+                pbf.pos += HEADER_LENGTH_BYTES;
+                state = "header";
+            }
+            else if (state === "header") {
+                blobHeader = readBlobHeader(pbf, pbf.pos + bytesNeeded);
+                bytesNeeded = blobHeader.datasize;
+                state = "blob";
+            }
+            else if (state === "blob") {
+                if (blobHeader == null)
+                    throw Error("Blob header has not been read");
+                const blob = readBlob(pbf, pbf.pos + bytesNeeded);
+                if (blob.zlib_data === undefined || blob.zlib_data.length === 0)
+                    throw Error("Blob has no zlib data. Format is unsupported.");
+                yield blob.zlib_data;
+                state = "header-length";
+                bytesNeeded = HEADER_LENGTH_BYTES;
+                blobHeader = null;
+            }
+        }
+    };
+}

package/dist/pbf-to-blocks.d.ts

@@ -0,0 +1,20 @@
+import { type OsmPbfBlock, type OsmPbfHeaderBlock } from "./proto/osmformat";
+import { type AsyncGeneratorValue } from "./utils";
+export declare const HEADER_LENGTH_BYTES = 4;
+/**
+ * Parses OSM PBF bytes from buffers, streams, or generators into header + block iterators.
+ * Returns the decoded header and a lazy async generator of primitive blocks.
+ */
+export declare function readOsmPbf(data: AsyncGeneratorValue<ArrayBufferLike>): Promise<{
+    header: OsmPbfHeaderBlock;
+    blocks: AsyncGenerator<OsmPbfBlock>;
+}>;
+/**
+ * Web `TransformStream` that turns raw PBF byte chunks into OSM header/data blocks.
+ * Assumes the first decoded blob carries the header and emits it before any primitive blocks.
+ */
+export declare class OsmPbfBytesToBlocksTransformStream extends TransformStream<ArrayBufferLike, OsmPbfHeaderBlock | OsmPbfBlock> {
+    generateBlobsFromChunk: (chunk: Uint8Array) => Generator<Uint8Array<ArrayBuffer>, void, unknown>;
+    header: OsmPbfHeaderBlock | null;
+    constructor();
+}

package/dist/pbf-to-blocks.js

@@ -0,0 +1,53 @@
+import Pbf from "pbf";
+import { osmPbfBlobsToBlocksGenerator } from "./blobs-to-blocks";
+import { createOsmPbfBlobGenerator } from "./pbf-to-blobs";
+import { readHeaderBlock, readPrimitiveBlock, } from "./proto/osmformat";
+import { decompress, toAsyncGenerator } from "./utils";
+export const HEADER_LENGTH_BYTES = 4;
+/**
+ * Parses OSM PBF bytes from buffers, streams, or generators into header + block iterators.
+ * Returns the decoded header and a lazy async generator of primitive blocks.
+ */
+export async function readOsmPbf(data) {
+    const generateBlobsFromChunk = createOsmPbfBlobGenerator();
+    const blocks = osmPbfBlobsToBlocksGenerator((async function* () {
+        for await (const chunk of toAsyncGenerator(data)) {
+            for await (const blob of generateBlobsFromChunk(new Uint8Array(chunk))) {
+                yield blob;
+            }
+        }
+    })());
+    const header = (await blocks.next()).value;
+    if (header == null || !("required_features" in header)) {
+        throw Error("OSM PBF header block not found");
+    }
+    return {
+        header,
+        blocks: blocks,
+    };
+}
+/**
+ * Web `TransformStream` that turns raw PBF byte chunks into OSM header/data blocks.
+ * Assumes the first decoded blob carries the header and emits it before any primitive blocks.
+ */
+export class OsmPbfBytesToBlocksTransformStream extends TransformStream {
+    generateBlobsFromChunk = createOsmPbfBlobGenerator();
+    header = null;
+    constructor() {
+        super({
+            transform: async (bytesChunk, controller) => {
+                for await (const rawBlobs of this.generateBlobsFromChunk(new Uint8Array(bytesChunk))) {
+                    const decompressed = await decompress(rawBlobs);
+                    const pbf = new Pbf(decompressed);
+                    if (this.header == null) {
+                        this.header = readHeaderBlock(pbf);
+                        controller.enqueue(this.header);
+                    }
+                    else {
+                        controller.enqueue(readPrimitiveBlock(pbf));
+                    }
+                }
+            },
+        });
+    }
+}

package/dist/proto/fileformat.d.ts

@@ -0,0 +1,26 @@
+import type Pbf from "pbf";
+export type OsmPbfBlob = {
+    raw_size?: number;
+    raw?: Uint8Array;
+    zlib_data?: Uint8Array;
+};
+export type OsmPbfBlobHeader = {
+    type: "OSMHeader" | "OSMData";
+    datasize: number;
+};
+/**
+ * Reads an `OsmPbfBlob` message from the current position in the Pbf reader.
+ */
+export declare function readBlob(pbf: Pbf, end?: number): OsmPbfBlob;
+/**
+ * Writes an `OsmPbfBlob` message to the provided Pbf writer.
+ */
+export declare function writeBlob(obj: OsmPbfBlob, pbf: Pbf): void;
+/**
+ * Reads an `OsmPbfBlobHeader` from the current position in the Pbf reader.
+ */
+export declare function readBlobHeader(pbf: Pbf, end?: number): OsmPbfBlobHeader;
+/**
+ * Writes an `OsmPbfBlobHeader` message to the provided Pbf writer.
+ */
+export declare function writeBlobHeader(obj: OsmPbfBlobHeader, pbf: Pbf): void;

package/dist/proto/fileformat.js

@@ -0,0 +1,56 @@
+/**
+ * Reads an `OsmPbfBlob` message from the current position in the Pbf reader.
+ */
+export function readBlob(pbf, end) {
+    return pbf.readFields(readBlobField, {
+        raw_size: 0,
+    }, end);
+}
+/**
+ * Dispatches individual Blob fields based on their protobuf tag.
+ */
+function readBlobField(tag, obj, pbf) {
+    if (tag === 2)
+        obj.raw_size = pbf.readVarint(true);
+    else if (tag === 1) {
+        obj.raw = pbf.readBytes();
+    }
+    else if (tag === 3) {
+        obj.zlib_data = pbf.readBytes();
+    }
+}
+/**
+ * Writes an `OsmPbfBlob` message to the provided Pbf writer.
+ */
+export function writeBlob(obj, pbf) {
+    if (obj.raw_size)
+        pbf.writeVarintField(2, obj.raw_size);
+    if (obj.raw != null)
+        pbf.writeBytesField(1, obj.raw);
+    if (obj.zlib_data != null)
+        pbf.writeBytesField(3, obj.zlib_data);
+}
+/**
+ * Reads an `OsmPbfBlobHeader` from the current position in the Pbf reader.
+ */
+export function readBlobHeader(pbf, end) {
+    return pbf.readFields(readBlobHeaderField, { type: "OSMData", datasize: 0 }, end);
+}
+/**
+ * Dispatches individual BlobHeader fields based on their protobuf tag.
+ */
+function readBlobHeaderField(tag, obj, pbf) {
+    if (tag === 1)
+        obj.type = pbf.readString();
+    else if (tag === 3)
+        obj.datasize = pbf.readVarint(true);
+}
+/**
+ * Writes an `OsmPbfBlobHeader` message to the provided Pbf writer.
+ */
+export function writeBlobHeader(obj, pbf) {
+    if (obj.type)
+        pbf.writeStringField(1, obj.type);
+    if (obj.datasize)
+        pbf.writeVarintField(3, obj.datasize);
+}

package/dist/proto/osmformat.d.ts

@@ -0,0 +1,91 @@
+import type Pbf from "pbf";
+export type OsmPbfHeaderBBox = {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+};
+export type OsmPbfHeaderBlock = {
+    bbox?: OsmPbfHeaderBBox;
+    required_features: string[];
+    optional_features: string[];
+    writingprogram?: string;
+    source?: string;
+    osmosis_replication_timestamp?: number;
+    osmosis_replication_sequence_number?: number;
+    osmosis_replication_base_url?: string;
+};
+export interface OsmPbfBlockSettings {
+    granularity?: number;
+    lat_offset?: number;
+    lon_offset?: number;
+    date_granularity?: number;
+}
+export interface OsmPbfBlock extends OsmPbfBlockSettings {
+    stringtable: OsmPbfStringTable;
+    primitivegroup: OsmPbfGroup[];
+}
+export type OsmPbfGroup = {
+    nodes: OsmPbfNode[];
+    dense?: OsmPbfDenseNodes;
+    ways: OsmPbfWay[];
+    relations: OsmPbfRelation[];
+};
+export type OsmPbfStringTable = Uint8Array[];
+export interface OsmPbfInfo {
+    version?: number;
+    timestamp?: number;
+    changeset?: number;
+    uid?: number;
+    user_sid?: number;
+    visible?: boolean;
+}
+export type OsmPbfDenseInfo = {
+    version: number[];
+    timestamp: number[];
+    changeset: number[];
+    uid: number[];
+    user_sid: number[];
+    visible: boolean[];
+};
+export interface OsmPbfPrimitive {
+    id: number;
+    keys: number[];
+    vals: number[];
+    info?: OsmPbfInfo;
+}
+export interface OsmPbfNode extends OsmPbfPrimitive {
+    lat: number;
+    lon: number;
+}
+export type OsmPbfDenseNodes = {
+    id: number[];
+    denseinfo?: OsmPbfDenseInfo;
+    lat: number[];
+    lon: number[];
+    keys_vals: number[];
+};
+export interface OsmPbfWay extends OsmPbfPrimitive {
+    refs: number[];
+}
+export interface OsmPbfRelation extends OsmPbfPrimitive {
+    roles_sid: number[];
+    memids: number[];
+    types: number[];
+}
+/**
+ * Reads an `OsmPbfHeaderBlock` message from the provided Pbf reader.
+ */
+export declare function readHeaderBlock(pbf: Pbf, end?: number): OsmPbfHeaderBlock;
+/**
+ * Serializes an `OsmPbfHeaderBlock` message into the Pbf writer.
+ */
+export declare function writeHeaderBlock(obj: OsmPbfHeaderBlock, pbf: Pbf): void;
+/**
+ * Reads a primitive block containing string tables and primitive groups.
+ */
+export declare function readPrimitiveBlock(pbf: Pbf, end?: number): OsmPbfBlock;
+/**
+ * Serializes a primitive block including its string table and primitive groups.
+ */
+export declare function writePrimitiveBlock(obj: OsmPbfBlock, pbf: Pbf): void;