catastrogps 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TheHiddenPanda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,127 @@
+# catastrogps
+
+Official JavaScript and TypeScript client for the [Catastro GPS API](https://www.catastrogps.es/developers): cadastral parcels in **29 European countries plus the Basque Country and Navarre** (31 country and region codes) with one API key.
+
+- Look up a parcel by its **official cadastral reference** or by **coordinates**, with the country detected for you.
+- Turn a **Spanish postal address in free text** into a cadastral reference.
+- Get the **parcel outline** (GeoJSON or a `[lat, lng]` ring), and **KML / GPX / DXF** exports.
+- **Solar** (PVGIS) and **agricultural** context for parcels in Spain, Portugal, France, Italy and Germany.
+- Zero runtime dependencies. Node.js 18+, Deno, Bun and edge runtimes with `fetch`. ESM and CommonJS, fully typed.
+
+**Free tier: 250 calls a month, forever. Failed lookups are not charged.** Get a key at [catastrogps.es/developers](https://www.catastrogps.es/developers).
+
+## Install
+
+```bash
+npm install catastrogps
+```
+
+## Quick start
+
+```ts
+import { CatastroGPS } from 'catastrogps';
+
+const client = new CatastroGPS({ apiKey: process.env.CATASTROGPS_API_KEY });
+
+const parcel = await client.parcels.get('9872023VH5797S0001WX');
+console.log(parcel.municipio, parcel.superficieParcela, parcel.latitud, parcel.longitud);
+```
+
+`new CatastroGPS()` with no arguments reads `CATASTROGPS_API_KEY` from the environment.
+
+## Examples
+
+```ts
+const fromAddress = await client.parcels.findByAddress('Calle Mallorca 213, Barcelona');
+fromAddress.referenciaCatastral;
+
+const inWarsaw = await client.parcels.atPoint({ lat: 52.2297, lng: 21.0122 });
+inWarsaw.referenciaCatastral;
+inWarsaw.pais;
+
+const foral = await client.parcels.get('<Navarre reference>', { country: 'NA' });
+
+const outline = await client.parcels.geometry('9872023VH5797S', { country: 'ES' });
+outline.geojson;
+
+const solar = await client.parcels.solar('9872023VH5797S0001WX');
+solar.kwh_year;
+
+const kml = await client.export.file('9872023VH5797S0001WX', 'kml');
+
+const guess = await client.resolve('05102200100005');
+guess.candidates;
+
+client.lastQuota;
+```
+
+Responses are the API's `data` object, with the field names the API uses (`refCatastral`, `municipio`, `superficieParcela`…). See the [API reference](https://www.catastrogps.es/developers).
+
+## Errors
+
+Every error is a `CatastroGPSError` with `status`, `code` and `details`. Subclasses let you branch cleanly:
+
+```ts
+import { AmbiguousReferenceError, CoverageError, NotFoundError, QuotaExceededError } from 'catastrogps';
+
+try {
+  await client.parcels.get('05102200100005');
+} catch (error) {
+  if (error instanceof AmbiguousReferenceError) {
+    const [first] = error.candidates;
+    await client.parcels.get('05102200100005', { country: first.country as 'DE' });
+  } else if (error instanceof NotFoundError || error instanceof CoverageError) {
+    console.log(error.message);
+  } else if (error instanceof QuotaExceededError) {
+    console.log('Monthly quota used up');
+  } else {
+    throw error;
+  }
+}
+```
+
+Also available: `AuthenticationError`, `ValidationError`, `RateLimitError`, `ServiceUnavailableError`, `ServerError`, `TimeoutError`, `NetworkError`.
+
+Timeouts, network errors, 429 rate limits and 502/503/504 are retried up to `maxRetries` times (default 2) with exponential backoff. An exhausted monthly quota is never retried. Each attempt that reaches the API counts as a call.
+
+## Options
+
+| Option | Default | |
+|--------|---------|---|
+| `apiKey` | `process.env.CATASTROGPS_API_KEY` | Required |
+| `baseUrl` | `https://api.catastrogps.es` | |
+| `timeoutMs` | `30000` | Official cadastres can be slow |
+| `maxRetries` | `2` | |
+| `fetch` | `globalThis.fetch` | Inject your own for tests or proxies |
+
+## Coverage
+
+| Code | Country / region | Reference | Coordinates | Notes |
+|------|------------------|:---:|:---:|-------|
+| `ES` | Spain | ✅ | ✅ | Free-text address search |
+| `PV` · `NA` | Basque Country · Navarre | ✅ | ✅ | Foral cadastres |
+| `PT` | Portugal | Partial | ✅ | Digital cadastre is partial |
+| `FR` · `IT` | France · Italy | ✅ | ✅ | |
+| `DE` | Germany | Partial | Partial | All Länder except Bavaria |
+| `AT` `CH` `LI` `BE` `NL` `LU` | Austria, Switzerland, Liechtenstein, Belgium, Netherlands, Luxembourg | ✅ | ✅ | |
+| `PL` `CZ` `SK` `SI` `HR` `BG` `GR` `CY` | Poland, Czechia, Slovakia, Slovenia, Croatia, Bulgaria, Greece, Cyprus | ✅ | ✅ | |
+| `DK` `NO` `FI` `IS` `EE` `LV` `LT` `IE` | Denmark, Norway, Finland, Iceland, Estonia, Latvia, Lithuania, Ireland | ✅ | ✅ | |
+| `SE` | Sweden | ✅ | ✅ | Agricultural blocks, not property units |
+| `UK` | United Kingdom | — | Scotland | England, Wales and Northern Ireland not yet |
+
+Geometry is available wherever a reference works. Solar and agriculture: `ES`, `PV`, `NA`, `PT`, `FR`, `IT`, `DE`. Data comes live from each official source, so availability follows theirs.
+
+## Pricing
+
+| Plan | Price | Calls / month |
+|------|-------|---------------|
+| Free | €0, forever | 100 |
+| Developer | €19 / month | 5,000 |
+| Startup | €49 / month | 15,000 |
+| Growth | €99 / month | 50,000 |
+
+The same key works with the Python SDK (`pip install catastrogps`) and the MCP server for AI agents ([`catastro-gps-mcp`](https://www.npmjs.com/package/catastro-gps-mcp)).
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,229 @@
+declare const COUNTRY_CODES: readonly ["ES", "PV", "NA", "PT", "FR", "IT", "DE", "AT", "CH", "LI", "BE", "NL", "LU", "PL", "CZ", "SK", "SI", "HR", "BG", "GR", "CY", "DK", "SE", "NO", "FI", "IS", "EE", "LV", "LT", "IE", "UK"];
+type CountryCode = (typeof COUNTRY_CODES)[number];
+declare const ENRICHMENT_COUNTRY_CODES: readonly ["ES", "PV", "NA", "PT", "FR", "IT", "DE"];
+type EnrichmentCountryCode = (typeof ENRICHMENT_COUNTRY_CODES)[number];
+type ExportFormat = 'kml' | 'gpx' | 'dxf';
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+interface CatastroGPSOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    fetch?: FetchLike;
+}
+interface CountryOption<C extends string = CountryCode> {
+    country?: C;
+}
+interface Quota {
+    plan?: string;
+    limit?: number;
+    remaining?: number;
+    resetsAt?: string;
+}
+interface Parcel {
+    refCatastral: string;
+    pais?: string;
+    direccion?: string;
+    codigoPostal?: string;
+    municipio?: string;
+    provincia?: string;
+    latitud: number;
+    longitud: number;
+    googleMapsUrl?: string;
+    uso?: string;
+    clase?: string;
+    superficieConstruida?: number;
+    superficieParcela?: number;
+    anioConstruccion?: number;
+    viviendas?: number;
+    plantas?: number;
+    fuenteDatos?: string;
+    dataSource?: string;
+    poligono?: number[][];
+    availableFields?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+interface PointMatch {
+    referenciaCatastral: string;
+    refCat14?: string;
+    pais?: string;
+    direccion?: string;
+    codigoPostal?: string;
+    municipio?: string;
+    provincia?: string;
+    tipoInmueble?: string;
+    coordenadas: {
+        latitud: number;
+        longitud: number;
+    };
+    googleMapsUrl?: string;
+    [key: string]: unknown;
+}
+interface AddressMatch {
+    referenciaCatastral: string;
+    refCat14?: string;
+    direccion?: string;
+    provincia?: string;
+    municipio?: string;
+    tipoVia?: string;
+    nombreVia?: string;
+    numero?: number;
+    planta?: string;
+    puerta?: string;
+    codigoPostal?: string;
+}
+interface ParcelGeometry {
+    refcat?: string;
+    refCatastral?: string;
+    pais?: string;
+    geojson?: unknown;
+    centroid?: {
+        latitude: number;
+        longitude: number;
+    };
+    latitud?: number;
+    longitud?: number;
+    area?: number;
+    superficieParcela?: number;
+    poligono?: number[][];
+    [key: string]: unknown;
+}
+interface SolarEstimate {
+    kwh_year: number;
+    kw_instalables: number;
+    ahorro_anual_eur: number;
+    amortizacion_anos: number;
+    co2_evitado_kg: number;
+    irradiacion_media: number;
+    nota_solar: number;
+    orientacion_optima?: string;
+    angulo_inclinacion?: number;
+    costo_instalacion_eur?: number;
+    disponible: boolean;
+    estado: string;
+    fuente?: string;
+    [key: string]: unknown;
+}
+type AgricultureData = Record<string, unknown>;
+interface ResolveCandidate {
+    country: string;
+    kind: 'reference' | 'coordinates' | 'place_name' | string;
+    normalized: string;
+    confidence: number;
+    supported: boolean;
+}
+interface ResolveResult {
+    input: string;
+    candidates: ResolveCandidate[];
+    ambiguous: boolean;
+}
+
+declare class ExportResource {
+    private readonly client;
+    constructor(client: CatastroGPS);
+    file(reference: string, format: ExportFormat, options?: CountryOption): Promise<ArrayBuffer>;
+}
+
+interface PointQuery extends CountryOption {
+    lat: number;
+    lng: number;
+}
+declare class ParcelsResource {
+    private readonly client;
+    constructor(client: CatastroGPS);
+    get(reference: string, options?: CountryOption): Promise<Parcel>;
+    atPoint(point: PointQuery): Promise<PointMatch>;
+    findByAddress(address: string): Promise<AddressMatch>;
+    geometry(reference: string, options?: CountryOption<Exclude<CountryCode, 'UK'>>): Promise<ParcelGeometry>;
+    solar(reference: string, options?: CountryOption<EnrichmentCountryCode>): Promise<SolarEstimate>;
+    agriculture(reference: string, options?: CountryOption<EnrichmentCountryCode>): Promise<AgricultureData>;
+}
+
+declare const DEFAULT_BASE_URL = "https://api.catastrogps.es";
+declare const DEFAULT_TIMEOUT_MS = 30000;
+declare const DEFAULT_MAX_RETRIES = 2;
+type Query = Record<string, string | number | undefined>;
+interface RequestOptions {
+    query?: Query;
+    body?: unknown;
+    raw?: boolean;
+}
+declare class CatastroGPS {
+    readonly parcels: ParcelsResource;
+    readonly export: ExportResource;
+    lastQuota?: Quota;
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    constructor(options?: CatastroGPSOptions);
+    resolve(text: string, options?: {
+        hint?: string;
+    }): Promise<ResolveResult>;
+    request<T>(method: 'GET' | 'POST', path: string, options?: RequestOptions): Promise<T>;
+    private once;
+    private buildUrl;
+    private shouldRetry;
+    private retryDelayMs;
+    private captureQuota;
+}
+
+declare const VERSION = "1.0.0";
+
+declare class CatastroGPSError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    readonly body: Record<string, unknown>;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        details?: unknown;
+        body?: Record<string, unknown>;
+    });
+}
+declare class AuthenticationError extends CatastroGPSError {
+    name: string;
+}
+declare class ForbiddenError extends CatastroGPSError {
+    name: string;
+}
+declare class NotFoundError extends CatastroGPSError {
+    name: string;
+}
+declare class ValidationError extends CatastroGPSError {
+    name: string;
+}
+declare class CoverageError extends CatastroGPSError {
+    name: string;
+}
+declare class AmbiguousReferenceError extends CatastroGPSError {
+    name: string;
+    get candidates(): Array<{
+        country: string;
+        confidence?: number;
+        supported?: boolean;
+    }>;
+}
+declare class QuotaExceededError extends CatastroGPSError {
+    name: string;
+}
+declare class RateLimitError extends CatastroGPSError {
+    name: string;
+    retryAfterSeconds?: number;
+}
+declare class ServiceUnavailableError extends CatastroGPSError {
+    name: string;
+}
+declare class ServerError extends CatastroGPSError {
+    name: string;
+}
+declare class TimeoutError extends CatastroGPSError {
+    name: string;
+}
+declare class NetworkError extends CatastroGPSError {
+    name: string;
+}
+
+export { type AddressMatch, type AgricultureData, AmbiguousReferenceError, AuthenticationError, COUNTRY_CODES, CatastroGPS, CatastroGPSError, type CatastroGPSOptions, type CountryCode, type CountryOption, CoverageError, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, ENRICHMENT_COUNTRY_CODES, type EnrichmentCountryCode, type ExportFormat, type FetchLike, ForbiddenError, NetworkError, NotFoundError, type Parcel, type ParcelGeometry, type PointMatch, type PointQuery, type Quota, QuotaExceededError, RateLimitError, type ResolveCandidate, type ResolveResult, ServerError, ServiceUnavailableError, type SolarEstimate, TimeoutError, VERSION, ValidationError };

package/dist/index.d.ts

@@ -0,0 +1,229 @@
+declare const COUNTRY_CODES: readonly ["ES", "PV", "NA", "PT", "FR", "IT", "DE", "AT", "CH", "LI", "BE", "NL", "LU", "PL", "CZ", "SK", "SI", "HR", "BG", "GR", "CY", "DK", "SE", "NO", "FI", "IS", "EE", "LV", "LT", "IE", "UK"];
+type CountryCode = (typeof COUNTRY_CODES)[number];
+declare const ENRICHMENT_COUNTRY_CODES: readonly ["ES", "PV", "NA", "PT", "FR", "IT", "DE"];
+type EnrichmentCountryCode = (typeof ENRICHMENT_COUNTRY_CODES)[number];
+type ExportFormat = 'kml' | 'gpx' | 'dxf';
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+interface CatastroGPSOptions {
+    apiKey?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    fetch?: FetchLike;
+}
+interface CountryOption<C extends string = CountryCode> {
+    country?: C;
+}
+interface Quota {
+    plan?: string;
+    limit?: number;
+    remaining?: number;
+    resetsAt?: string;
+}
+interface Parcel {
+    refCatastral: string;
+    pais?: string;
+    direccion?: string;
+    codigoPostal?: string;
+    municipio?: string;
+    provincia?: string;
+    latitud: number;
+    longitud: number;
+    googleMapsUrl?: string;
+    uso?: string;
+    clase?: string;
+    superficieConstruida?: number;
+    superficieParcela?: number;
+    anioConstruccion?: number;
+    viviendas?: number;
+    plantas?: number;
+    fuenteDatos?: string;
+    dataSource?: string;
+    poligono?: number[][];
+    availableFields?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+interface PointMatch {
+    referenciaCatastral: string;
+    refCat14?: string;
+    pais?: string;
+    direccion?: string;
+    codigoPostal?: string;
+    municipio?: string;
+    provincia?: string;
+    tipoInmueble?: string;
+    coordenadas: {
+        latitud: number;
+        longitud: number;
+    };
+    googleMapsUrl?: string;
+    [key: string]: unknown;
+}
+interface AddressMatch {
+    referenciaCatastral: string;
+    refCat14?: string;
+    direccion?: string;
+    provincia?: string;
+    municipio?: string;
+    tipoVia?: string;
+    nombreVia?: string;
+    numero?: number;
+    planta?: string;
+    puerta?: string;
+    codigoPostal?: string;
+}
+interface ParcelGeometry {
+    refcat?: string;
+    refCatastral?: string;
+    pais?: string;
+    geojson?: unknown;
+    centroid?: {
+        latitude: number;
+        longitude: number;
+    };
+    latitud?: number;
+    longitud?: number;
+    area?: number;
+    superficieParcela?: number;
+    poligono?: number[][];
+    [key: string]: unknown;
+}
+interface SolarEstimate {
+    kwh_year: number;
+    kw_instalables: number;
+    ahorro_anual_eur: number;
+    amortizacion_anos: number;
+    co2_evitado_kg: number;
+    irradiacion_media: number;
+    nota_solar: number;
+    orientacion_optima?: string;
+    angulo_inclinacion?: number;
+    costo_instalacion_eur?: number;
+    disponible: boolean;
+    estado: string;
+    fuente?: string;
+    [key: string]: unknown;
+}
+type AgricultureData = Record<string, unknown>;
+interface ResolveCandidate {
+    country: string;
+    kind: 'reference' | 'coordinates' | 'place_name' | string;
+    normalized: string;
+    confidence: number;
+    supported: boolean;
+}
+interface ResolveResult {
+    input: string;
+    candidates: ResolveCandidate[];
+    ambiguous: boolean;
+}
+
+declare class ExportResource {
+    private readonly client;
+    constructor(client: CatastroGPS);
+    file(reference: string, format: ExportFormat, options?: CountryOption): Promise<ArrayBuffer>;
+}
+
+interface PointQuery extends CountryOption {
+    lat: number;
+    lng: number;
+}
+declare class ParcelsResource {
+    private readonly client;
+    constructor(client: CatastroGPS);
+    get(reference: string, options?: CountryOption): Promise<Parcel>;
+    atPoint(point: PointQuery): Promise<PointMatch>;
+    findByAddress(address: string): Promise<AddressMatch>;
+    geometry(reference: string, options?: CountryOption<Exclude<CountryCode, 'UK'>>): Promise<ParcelGeometry>;
+    solar(reference: string, options?: CountryOption<EnrichmentCountryCode>): Promise<SolarEstimate>;
+    agriculture(reference: string, options?: CountryOption<EnrichmentCountryCode>): Promise<AgricultureData>;
+}
+
+declare const DEFAULT_BASE_URL = "https://api.catastrogps.es";
+declare const DEFAULT_TIMEOUT_MS = 30000;
+declare const DEFAULT_MAX_RETRIES = 2;
+type Query = Record<string, string | number | undefined>;
+interface RequestOptions {
+    query?: Query;
+    body?: unknown;
+    raw?: boolean;
+}
+declare class CatastroGPS {
+    readonly parcels: ParcelsResource;
+    readonly export: ExportResource;
+    lastQuota?: Quota;
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly timeoutMs;
+    private readonly maxRetries;
+    private readonly fetchImpl;
+    constructor(options?: CatastroGPSOptions);
+    resolve(text: string, options?: {
+        hint?: string;
+    }): Promise<ResolveResult>;
+    request<T>(method: 'GET' | 'POST', path: string, options?: RequestOptions): Promise<T>;
+    private once;
+    private buildUrl;
+    private shouldRetry;
+    private retryDelayMs;
+    private captureQuota;
+}
+
+declare const VERSION = "1.0.0";
+
+declare class CatastroGPSError extends Error {
+    readonly status?: number;
+    readonly code?: string;
+    readonly details?: unknown;
+    readonly body: Record<string, unknown>;
+    constructor(message: string, options?: {
+        status?: number;
+        code?: string;
+        details?: unknown;
+        body?: Record<string, unknown>;
+    });
+}
+declare class AuthenticationError extends CatastroGPSError {
+    name: string;
+}
+declare class ForbiddenError extends CatastroGPSError {
+    name: string;
+}
+declare class NotFoundError extends CatastroGPSError {
+    name: string;
+}
+declare class ValidationError extends CatastroGPSError {
+    name: string;
+}
+declare class CoverageError extends CatastroGPSError {
+    name: string;
+}
+declare class AmbiguousReferenceError extends CatastroGPSError {
+    name: string;
+    get candidates(): Array<{
+        country: string;
+        confidence?: number;
+        supported?: boolean;
+    }>;
+}
+declare class QuotaExceededError extends CatastroGPSError {
+    name: string;
+}
+declare class RateLimitError extends CatastroGPSError {
+    name: string;
+    retryAfterSeconds?: number;
+}
+declare class ServiceUnavailableError extends CatastroGPSError {
+    name: string;
+}
+declare class ServerError extends CatastroGPSError {
+    name: string;
+}
+declare class TimeoutError extends CatastroGPSError {
+    name: string;
+}
+declare class NetworkError extends CatastroGPSError {
+    name: string;
+}
+
+export { type AddressMatch, type AgricultureData, AmbiguousReferenceError, AuthenticationError, COUNTRY_CODES, CatastroGPS, CatastroGPSError, type CatastroGPSOptions, type CountryCode, type CountryOption, CoverageError, DEFAULT_BASE_URL, DEFAULT_MAX_RETRIES, DEFAULT_TIMEOUT_MS, ENRICHMENT_COUNTRY_CODES, type EnrichmentCountryCode, type ExportFormat, type FetchLike, ForbiddenError, NetworkError, NotFoundError, type Parcel, type ParcelGeometry, type PointMatch, type PointQuery, type Quota, QuotaExceededError, RateLimitError, type ResolveCandidate, type ResolveResult, ServerError, ServiceUnavailableError, type SolarEstimate, TimeoutError, VERSION, ValidationError };

package/dist/index.js

@@ -0,0 +1,372 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AmbiguousReferenceError: () => AmbiguousReferenceError,
+  AuthenticationError: () => AuthenticationError,
+  COUNTRY_CODES: () => COUNTRY_CODES,
+  CatastroGPS: () => CatastroGPS,
+  CatastroGPSError: () => CatastroGPSError,
+  CoverageError: () => CoverageError,
+  DEFAULT_BASE_URL: () => DEFAULT_BASE_URL,
+  DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT_MS: () => DEFAULT_TIMEOUT_MS,
+  ENRICHMENT_COUNTRY_CODES: () => ENRICHMENT_COUNTRY_CODES,
+  ForbiddenError: () => ForbiddenError,
+  NetworkError: () => NetworkError,
+  NotFoundError: () => NotFoundError,
+  QuotaExceededError: () => QuotaExceededError,
+  RateLimitError: () => RateLimitError,
+  ServerError: () => ServerError,
+  ServiceUnavailableError: () => ServiceUnavailableError,
+  TimeoutError: () => TimeoutError,
+  VERSION: () => VERSION,
+  ValidationError: () => ValidationError
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var CatastroGPSError = class extends Error {
+  status;
+  code;
+  details;
+  body;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CatastroGPSError";
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+    this.body = options.body ?? {};
+  }
+};
+var AuthenticationError = class extends CatastroGPSError {
+  name = "AuthenticationError";
+};
+var ForbiddenError = class extends CatastroGPSError {
+  name = "ForbiddenError";
+};
+var NotFoundError = class extends CatastroGPSError {
+  name = "NotFoundError";
+};
+var ValidationError = class extends CatastroGPSError {
+  name = "ValidationError";
+};
+var CoverageError = class extends CatastroGPSError {
+  name = "CoverageError";
+};
+var AmbiguousReferenceError = class extends CatastroGPSError {
+  name = "AmbiguousReferenceError";
+  get candidates() {
+    const details = this.details;
+    return details?.candidates ?? [];
+  }
+};
+var QuotaExceededError = class extends CatastroGPSError {
+  name = "QuotaExceededError";
+};
+var RateLimitError = class extends CatastroGPSError {
+  name = "RateLimitError";
+  retryAfterSeconds;
+};
+var ServiceUnavailableError = class extends CatastroGPSError {
+  name = "ServiceUnavailableError";
+};
+var ServerError = class extends CatastroGPSError {
+  name = "ServerError";
+};
+var TimeoutError = class extends CatastroGPSError {
+  name = "TimeoutError";
+};
+var NetworkError = class extends CatastroGPSError {
+  name = "NetworkError";
+};
+function errorFromResponse(status, body, retryAfter) {
+  const code = typeof body.code === "string" ? body.code : void 0;
+  const message = typeof body.error === "string" && body.error || typeof body.message === "string" && body.message || `HTTP ${status}`;
+  const details = body.data ?? body.parsed;
+  const options = { status, code, details, body };
+  if (code === "CNV_AMBIGUOUS" || status === 300) return new AmbiguousReferenceError(message, options);
+  if (code === "CNV_COVERAGE") return new CoverageError(message, options);
+  if (code === "KEY_AUTH_004") return new QuotaExceededError(message, options);
+  if (status === 429) {
+    const error = new RateLimitError(message, options);
+    error.retryAfterSeconds = retryAfter;
+    return error;
+  }
+  if (status === 401) return new AuthenticationError(message, options);
+  if (status === 403) return new ForbiddenError(message, options);
+  if (status === 404) return new NotFoundError(message, options);
+  if (status === 400 || status === 422) return new ValidationError(message, options);
+  if (status === 503) return new ServiceUnavailableError(message, options);
+  if (status >= 500) return new ServerError(message, options);
+  return new CatastroGPSError(message, options);
+}
+
+// src/resources/export.ts
+var FORMATS = ["kml", "gpx", "dxf"];
+var ExportResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async file(reference, format, options = {}) {
+    if (!FORMATS.includes(format)) {
+      throw new CatastroGPSError(`format must be one of ${FORMATS.join(", ")}`);
+    }
+    if (!reference.trim()) throw new CatastroGPSError("reference must not be empty");
+    return this.client.request("GET", `/api/export/${format}`, {
+      query: { refcat: reference.trim(), country: options.country },
+      raw: true
+    });
+  }
+};
+
+// src/resources/parcels.ts
+var ParcelsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async get(reference, options = {}) {
+    return this.client.request("GET", parcelPath(reference), { query: { country: options.country } });
+  }
+  async atPoint(point) {
+    if (!Number.isFinite(point.lat) || !Number.isFinite(point.lng)) {
+      throw new CatastroGPSError("lat and lng must be finite numbers");
+    }
+    return this.client.request("GET", "/api/search/coordinates", {
+      query: { lat: point.lat, lng: point.lng, country: point.country }
+    });
+  }
+  async findByAddress(address) {
+    if (!address.trim()) throw new CatastroGPSError("address must not be empty");
+    return this.client.request("POST", "/api/search/address/parse", { body: { direccion: address } });
+  }
+  async geometry(reference, options = {}) {
+    return this.client.request("GET", parcelPath(reference, "/polygon"), { query: { country: options.country } });
+  }
+  async solar(reference, options = {}) {
+    return this.client.request("GET", parcelPath(reference, "/solar"), { query: { country: options.country } });
+  }
+  async agriculture(reference, options = {}) {
+    const data = await this.client.request("GET", parcelPath(reference, "/agro"), {
+      query: { country: options.country }
+    });
+    return data.agro ?? data;
+  }
+};
+function parcelPath(reference, suffix = "") {
+  if (!reference.trim()) throw new CatastroGPSError("reference must not be empty");
+  return `/api/catastro/${encodeURIComponent(reference.trim())}${suffix}`;
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.catastrogps.es";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var BACKOFF_BASE_MS = 500;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([502, 503, 504]);
+var CatastroGPS = class {
+  parcels;
+  export;
+  lastQuota;
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? readEnv("CATASTROGPS_API_KEY");
+    if (!apiKey) {
+      throw new CatastroGPSError(
+        "An API key is required: pass { apiKey } or set CATASTROGPS_API_KEY. Get a free key at https://www.catastrogps.es/developers"
+      );
+    }
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new CatastroGPSError("No fetch implementation found. Use Node.js 18+ or pass { fetch }.");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = Math.max(0, options.maxRetries ?? DEFAULT_MAX_RETRIES);
+    this.fetchImpl = fetchImpl;
+    this.parcels = new ParcelsResource(this);
+    this.export = new ExportResource(this);
+  }
+  async resolve(text, options = {}) {
+    return this.request("GET", "/api/resolve", { query: { q: text, hint: options.hint } });
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    let attempt = 0;
+    for (; ; ) {
+      try {
+        return await this.once(method, url, options);
+      } catch (error) {
+        if (!this.shouldRetry(error, attempt)) throw error;
+        await sleep(this.retryDelayMs(error, attempt));
+        attempt += 1;
+      }
+    }
+  }
+  async once(method, url, options) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const headers = {
+      "X-API-Key": this.apiKey,
+      Accept: options.raw ? "*/*" : "application/json",
+      "User-Agent": `catastrogps-js/${VERSION}`
+    };
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${this.timeoutMs} ms`);
+      }
+      throw new NetworkError(`Network error: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      clearTimeout(timer);
+    }
+    this.captureQuota(response.headers);
+    if (!response.ok) {
+      const body2 = await readJson(response);
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      throw errorFromResponse(response.status, body2, Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : void 0);
+    }
+    if (options.raw) return await response.arrayBuffer();
+    const body = await readJson(response);
+    return "data" in body ? body.data : body;
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== void 0 && value !== "") url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  shouldRetry(error, attempt) {
+    if (attempt >= this.maxRetries) return false;
+    if (error instanceof TimeoutError || error instanceof NetworkError) return true;
+    if (error instanceof RateLimitError) return true;
+    return error instanceof CatastroGPSError && error.status !== void 0 && RETRYABLE_STATUS.has(error.status);
+  }
+  retryDelayMs(error, attempt) {
+    if (error instanceof RateLimitError && error.retryAfterSeconds) return error.retryAfterSeconds * 1e3;
+    return BACKOFF_BASE_MS * 2 ** attempt;
+  }
+  captureQuota(headers) {
+    const limit = headers.get("X-RateLimit-Limit");
+    if (limit === null) return;
+    const remaining = headers.get("X-RateLimit-Remaining");
+    this.lastQuota = {
+      plan: headers.get("X-Quota-Tier") ?? void 0,
+      limit: Number(limit),
+      remaining: remaining === null ? void 0 : Number(remaining),
+      resetsAt: headers.get("X-RateLimit-Reset") ?? void 0
+    };
+  }
+};
+async function readJson(response) {
+  try {
+    const parsed = await response.json();
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readEnv(name) {
+  const env = globalThis.process?.env;
+  return env?.[name] || void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/types.ts
+var COUNTRY_CODES = [
+  "ES",
+  "PV",
+  "NA",
+  "PT",
+  "FR",
+  "IT",
+  "DE",
+  "AT",
+  "CH",
+  "LI",
+  "BE",
+  "NL",
+  "LU",
+  "PL",
+  "CZ",
+  "SK",
+  "SI",
+  "HR",
+  "BG",
+  "GR",
+  "CY",
+  "DK",
+  "SE",
+  "NO",
+  "FI",
+  "IS",
+  "EE",
+  "LV",
+  "LT",
+  "IE",
+  "UK"
+];
+var ENRICHMENT_COUNTRY_CODES = ["ES", "PV", "NA", "PT", "FR", "IT", "DE"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AmbiguousReferenceError,
+  AuthenticationError,
+  COUNTRY_CODES,
+  CatastroGPS,
+  CatastroGPSError,
+  CoverageError,
+  DEFAULT_BASE_URL,
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT_MS,
+  ENRICHMENT_COUNTRY_CODES,
+  ForbiddenError,
+  NetworkError,
+  NotFoundError,
+  QuotaExceededError,
+  RateLimitError,
+  ServerError,
+  ServiceUnavailableError,
+  TimeoutError,
+  VERSION,
+  ValidationError
+});

package/dist/index.mjs

@@ -0,0 +1,326 @@
+// src/errors.ts
+var CatastroGPSError = class extends Error {
+  status;
+  code;
+  details;
+  body;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "CatastroGPSError";
+    this.status = options.status;
+    this.code = options.code;
+    this.details = options.details;
+    this.body = options.body ?? {};
+  }
+};
+var AuthenticationError = class extends CatastroGPSError {
+  name = "AuthenticationError";
+};
+var ForbiddenError = class extends CatastroGPSError {
+  name = "ForbiddenError";
+};
+var NotFoundError = class extends CatastroGPSError {
+  name = "NotFoundError";
+};
+var ValidationError = class extends CatastroGPSError {
+  name = "ValidationError";
+};
+var CoverageError = class extends CatastroGPSError {
+  name = "CoverageError";
+};
+var AmbiguousReferenceError = class extends CatastroGPSError {
+  name = "AmbiguousReferenceError";
+  get candidates() {
+    const details = this.details;
+    return details?.candidates ?? [];
+  }
+};
+var QuotaExceededError = class extends CatastroGPSError {
+  name = "QuotaExceededError";
+};
+var RateLimitError = class extends CatastroGPSError {
+  name = "RateLimitError";
+  retryAfterSeconds;
+};
+var ServiceUnavailableError = class extends CatastroGPSError {
+  name = "ServiceUnavailableError";
+};
+var ServerError = class extends CatastroGPSError {
+  name = "ServerError";
+};
+var TimeoutError = class extends CatastroGPSError {
+  name = "TimeoutError";
+};
+var NetworkError = class extends CatastroGPSError {
+  name = "NetworkError";
+};
+function errorFromResponse(status, body, retryAfter) {
+  const code = typeof body.code === "string" ? body.code : void 0;
+  const message = typeof body.error === "string" && body.error || typeof body.message === "string" && body.message || `HTTP ${status}`;
+  const details = body.data ?? body.parsed;
+  const options = { status, code, details, body };
+  if (code === "CNV_AMBIGUOUS" || status === 300) return new AmbiguousReferenceError(message, options);
+  if (code === "CNV_COVERAGE") return new CoverageError(message, options);
+  if (code === "KEY_AUTH_004") return new QuotaExceededError(message, options);
+  if (status === 429) {
+    const error = new RateLimitError(message, options);
+    error.retryAfterSeconds = retryAfter;
+    return error;
+  }
+  if (status === 401) return new AuthenticationError(message, options);
+  if (status === 403) return new ForbiddenError(message, options);
+  if (status === 404) return new NotFoundError(message, options);
+  if (status === 400 || status === 422) return new ValidationError(message, options);
+  if (status === 503) return new ServiceUnavailableError(message, options);
+  if (status >= 500) return new ServerError(message, options);
+  return new CatastroGPSError(message, options);
+}
+
+// src/resources/export.ts
+var FORMATS = ["kml", "gpx", "dxf"];
+var ExportResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async file(reference, format, options = {}) {
+    if (!FORMATS.includes(format)) {
+      throw new CatastroGPSError(`format must be one of ${FORMATS.join(", ")}`);
+    }
+    if (!reference.trim()) throw new CatastroGPSError("reference must not be empty");
+    return this.client.request("GET", `/api/export/${format}`, {
+      query: { refcat: reference.trim(), country: options.country },
+      raw: true
+    });
+  }
+};
+
+// src/resources/parcels.ts
+var ParcelsResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async get(reference, options = {}) {
+    return this.client.request("GET", parcelPath(reference), { query: { country: options.country } });
+  }
+  async atPoint(point) {
+    if (!Number.isFinite(point.lat) || !Number.isFinite(point.lng)) {
+      throw new CatastroGPSError("lat and lng must be finite numbers");
+    }
+    return this.client.request("GET", "/api/search/coordinates", {
+      query: { lat: point.lat, lng: point.lng, country: point.country }
+    });
+  }
+  async findByAddress(address) {
+    if (!address.trim()) throw new CatastroGPSError("address must not be empty");
+    return this.client.request("POST", "/api/search/address/parse", { body: { direccion: address } });
+  }
+  async geometry(reference, options = {}) {
+    return this.client.request("GET", parcelPath(reference, "/polygon"), { query: { country: options.country } });
+  }
+  async solar(reference, options = {}) {
+    return this.client.request("GET", parcelPath(reference, "/solar"), { query: { country: options.country } });
+  }
+  async agriculture(reference, options = {}) {
+    const data = await this.client.request("GET", parcelPath(reference, "/agro"), {
+      query: { country: options.country }
+    });
+    return data.agro ?? data;
+  }
+};
+function parcelPath(reference, suffix = "") {
+  if (!reference.trim()) throw new CatastroGPSError("reference must not be empty");
+  return `/api/catastro/${encodeURIComponent(reference.trim())}${suffix}`;
+}
+
+// src/version.ts
+var VERSION = "1.0.0";
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.catastrogps.es";
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_RETRIES = 2;
+var BACKOFF_BASE_MS = 500;
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([502, 503, 504]);
+var CatastroGPS = class {
+  parcels;
+  export;
+  lastQuota;
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  maxRetries;
+  fetchImpl;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? readEnv("CATASTROGPS_API_KEY");
+    if (!apiKey) {
+      throw new CatastroGPSError(
+        "An API key is required: pass { apiKey } or set CATASTROGPS_API_KEY. Get a free key at https://www.catastrogps.es/developers"
+      );
+    }
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if (!fetchImpl) {
+      throw new CatastroGPSError("No fetch implementation found. Use Node.js 18+ or pass { fetch }.");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRetries = Math.max(0, options.maxRetries ?? DEFAULT_MAX_RETRIES);
+    this.fetchImpl = fetchImpl;
+    this.parcels = new ParcelsResource(this);
+    this.export = new ExportResource(this);
+  }
+  async resolve(text, options = {}) {
+    return this.request("GET", "/api/resolve", { query: { q: text, hint: options.hint } });
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.query);
+    let attempt = 0;
+    for (; ; ) {
+      try {
+        return await this.once(method, url, options);
+      } catch (error) {
+        if (!this.shouldRetry(error, attempt)) throw error;
+        await sleep(this.retryDelayMs(error, attempt));
+        attempt += 1;
+      }
+    }
+  }
+  async once(method, url, options) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    const headers = {
+      "X-API-Key": this.apiKey,
+      Accept: options.raw ? "*/*" : "application/json",
+      "User-Agent": `catastrogps-js/${VERSION}`
+    };
+    if (options.body !== void 0) headers["Content-Type"] = "application/json";
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method,
+        headers,
+        body: options.body === void 0 ? void 0 : JSON.stringify(options.body),
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${this.timeoutMs} ms`);
+      }
+      throw new NetworkError(`Network error: ${error instanceof Error ? error.message : String(error)}`);
+    } finally {
+      clearTimeout(timer);
+    }
+    this.captureQuota(response.headers);
+    if (!response.ok) {
+      const body2 = await readJson(response);
+      const retryAfter = Number(response.headers.get("Retry-After"));
+      throw errorFromResponse(response.status, body2, Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter : void 0);
+    }
+    if (options.raw) return await response.arrayBuffer();
+    const body = await readJson(response);
+    return "data" in body ? body.data : body;
+  }
+  buildUrl(path, query) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {})) {
+      if (value !== void 0 && value !== "") url.searchParams.set(key, String(value));
+    }
+    return url.toString();
+  }
+  shouldRetry(error, attempt) {
+    if (attempt >= this.maxRetries) return false;
+    if (error instanceof TimeoutError || error instanceof NetworkError) return true;
+    if (error instanceof RateLimitError) return true;
+    return error instanceof CatastroGPSError && error.status !== void 0 && RETRYABLE_STATUS.has(error.status);
+  }
+  retryDelayMs(error, attempt) {
+    if (error instanceof RateLimitError && error.retryAfterSeconds) return error.retryAfterSeconds * 1e3;
+    return BACKOFF_BASE_MS * 2 ** attempt;
+  }
+  captureQuota(headers) {
+    const limit = headers.get("X-RateLimit-Limit");
+    if (limit === null) return;
+    const remaining = headers.get("X-RateLimit-Remaining");
+    this.lastQuota = {
+      plan: headers.get("X-Quota-Tier") ?? void 0,
+      limit: Number(limit),
+      remaining: remaining === null ? void 0 : Number(remaining),
+      resetsAt: headers.get("X-RateLimit-Reset") ?? void 0
+    };
+  }
+};
+async function readJson(response) {
+  try {
+    const parsed = await response.json();
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function readEnv(name) {
+  const env = globalThis.process?.env;
+  return env?.[name] || void 0;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/types.ts
+var COUNTRY_CODES = [
+  "ES",
+  "PV",
+  "NA",
+  "PT",
+  "FR",
+  "IT",
+  "DE",
+  "AT",
+  "CH",
+  "LI",
+  "BE",
+  "NL",
+  "LU",
+  "PL",
+  "CZ",
+  "SK",
+  "SI",
+  "HR",
+  "BG",
+  "GR",
+  "CY",
+  "DK",
+  "SE",
+  "NO",
+  "FI",
+  "IS",
+  "EE",
+  "LV",
+  "LT",
+  "IE",
+  "UK"
+];
+var ENRICHMENT_COUNTRY_CODES = ["ES", "PV", "NA", "PT", "FR", "IT", "DE"];
+export {
+  AmbiguousReferenceError,
+  AuthenticationError,
+  COUNTRY_CODES,
+  CatastroGPS,
+  CatastroGPSError,
+  CoverageError,
+  DEFAULT_BASE_URL,
+  DEFAULT_MAX_RETRIES,
+  DEFAULT_TIMEOUT_MS,
+  ENRICHMENT_COUNTRY_CODES,
+  ForbiddenError,
+  NetworkError,
+  NotFoundError,
+  QuotaExceededError,
+  RateLimitError,
+  ServerError,
+  ServiceUnavailableError,
+  TimeoutError,
+  VERSION,
+  ValidationError
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "catastrogps",
+  "version": "1.0.0",
+  "description": "Official JavaScript/TypeScript client for the Catastro GPS API: cadastral parcels in 31 European countries and regions by reference, coordinates or Spanish address",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run typecheck && npm test && npm run build"
+  },
+  "keywords": [
+    "cadastre",
+    "cadastral",
+    "catastro",
+    "cadastre-api",
+    "catastro-api",
+    "parcel",
+    "land-registry",
+    "gis",
+    "geojson",
+    "europe",
+    "spain",
+    "portugal",
+    "france",
+    "italy",
+    "germany",
+    "real-estate",
+    "proptech",
+    "sdk"
+  ],
+  "author": "The Hidden Panda <soporte@catastrogps.es>",
+  "license": "MIT",
+  "homepage": "https://www.catastrogps.es/developers",
+  "bugs": {
+    "email": "soporte@catastrogps.es"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.0.0",
+    "@types/node": "^22.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}