iptuapi 2.0.2 → 2.1.0

package/dist/index.js

@@ -21,7 +21,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   AuthenticationError: () => AuthenticationError,
-  CidadeEnum: () => CidadeEnum,
   ForbiddenError: () => ForbiddenError,
   IPTUAPIError: () => IPTUAPIError,
   IPTUClient: () => IPTUClient,
@@ -30,519 +29,618 @@ __export(index_exports, {
   RateLimitError: () => RateLimitError,
   ServerError: () => ServerError,
   TimeoutError: () => TimeoutError,
-  ValidationError: () => ValidationError,
-  default: () => index_default
+  ValidationError: () => ValidationError
 });
 module.exports = __toCommonJS(index_exports);
-var CidadeEnum = {
-  SAO_PAULO: "sp",
-  BELO_HORIZONTE: "bh",
-  RECIFE: "recife"
-};
+
+// src/errors.ts
 var IPTUAPIError = class _IPTUAPIError extends Error {
   statusCode;
   requestId;
-  responseBody;
-  constructor(message, statusCode, requestId, responseBody) {
+  responseData;
+  constructor(message, statusCode, requestId, responseData) {
     super(message);
     this.name = "IPTUAPIError";
     this.statusCode = statusCode;
     this.requestId = requestId;
-    this.responseBody = responseBody;
+    this.responseData = responseData || {};
     Object.setPrototypeOf(this, _IPTUAPIError.prototype);
   }
-  get isRetryable() {
-    return this.statusCode ? [429, 500, 502, 503, 504].includes(this.statusCode) : false;
+  isRetryable() {
+    return false;
+  }
+  toJSON() {
+    return {
+      error: this.name,
+      message: this.message,
+      statusCode: this.statusCode,
+      requestId: this.requestId,
+      retryable: this.isRetryable()
+    };
   }
 };
 var AuthenticationError = class _AuthenticationError extends IPTUAPIError {
-  constructor(message = "API Key inv\xE1lida ou expirada", requestId, responseBody) {
-    super(message, 401, requestId, responseBody);
+  constructor(message = "API Key invalida ou ausente", requestId) {
+    super(message, 401, requestId);
     this.name = "AuthenticationError";
     Object.setPrototypeOf(this, _AuthenticationError.prototype);
   }
 };
 var ForbiddenError = class _ForbiddenError extends IPTUAPIError {
   requiredPlan;
-  constructor(message = "Plano n\xE3o autorizado para este recurso", requiredPlan, requestId, responseBody) {
-    super(message, 403, requestId, responseBody);
+  constructor(message = "Acesso negado", requiredPlan, requestId) {
+    super(message, 403, requestId);
     this.name = "ForbiddenError";
     this.requiredPlan = requiredPlan;
     Object.setPrototypeOf(this, _ForbiddenError.prototype);
   }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      requiredPlan: this.requiredPlan
+    };
+  }
 };
 var NotFoundError = class _NotFoundError extends IPTUAPIError {
-  constructor(message = "Recurso n\xE3o encontrado", requestId, responseBody) {
-    super(message, 404, requestId, responseBody);
+  resource;
+  constructor(message = "Recurso nao encontrado", resource, requestId) {
+    super(message, 404, requestId);
     this.name = "NotFoundError";
+    this.resource = resource;
     Object.setPrototypeOf(this, _NotFoundError.prototype);
   }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      resource: this.resource
+    };
+  }
 };
 var RateLimitError = class _RateLimitError extends IPTUAPIError {
   retryAfter;
-  limit;
-  remaining;
-  constructor(message = "Limite de requisi\xE7\xF5es excedido", retryAfter, limit, remaining, requestId, responseBody) {
-    super(message, 429, requestId, responseBody);
+  constructor(message = "Rate limit excedido", retryAfter = 60, requestId) {
+    super(message, 429, requestId);
     this.name = "RateLimitError";
     this.retryAfter = retryAfter;
-    this.limit = limit;
-    this.remaining = remaining;
     Object.setPrototypeOf(this, _RateLimitError.prototype);
   }
-  get isRetryable() {
+  isRetryable() {
     return true;
   }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      retryAfter: this.retryAfter
+    };
+  }
 };
 var ValidationError = class _ValidationError extends IPTUAPIError {
   errors;
-  constructor(message = "Par\xE2metros inv\xE1lidos", errors, requestId, responseBody) {
-    super(message, 400, requestId, responseBody);
+  constructor(message = "Parametros invalidos", errors, statusCode = 422, requestId) {
+    super(message, statusCode, requestId);
     this.name = "ValidationError";
-    this.errors = errors;
+    this.errors = errors || {};
     Object.setPrototypeOf(this, _ValidationError.prototype);
   }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      validationErrors: this.errors
+    };
+  }
 };
 var ServerError = class _ServerError extends IPTUAPIError {
-  constructor(message = "Erro interno do servidor", statusCode = 500, requestId, responseBody) {
-    super(message, statusCode, requestId, responseBody);
+  constructor(message = "Erro interno do servidor", statusCode = 500, requestId) {
+    super(message, statusCode, requestId);
     this.name = "ServerError";
     Object.setPrototypeOf(this, _ServerError.prototype);
   }
-  get isRetryable() {
+  isRetryable() {
     return true;
   }
 };
 var TimeoutError = class _TimeoutError extends IPTUAPIError {
-  timeoutMs;
-  constructor(message = "Timeout na requisi\xE7\xE3o", timeoutMs) {
-    super(message, 408);
+  timeoutSeconds;
+  constructor(message = "Timeout na requisicao", timeoutSeconds, requestId) {
+    super(message, 408, requestId);
     this.name = "TimeoutError";
-    this.timeoutMs = timeoutMs;
+    this.timeoutSeconds = timeoutSeconds;
     Object.setPrototypeOf(this, _TimeoutError.prototype);
   }
-  get isRetryable() {
+  isRetryable() {
     return true;
   }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      timeoutSeconds: this.timeoutSeconds
+    };
+  }
 };
 var NetworkError = class _NetworkError extends IPTUAPIError {
   originalError;
-  constructor(message = "Erro de conex\xE3o com a API", originalError) {
-    super(message);
+  constructor(message = "Erro de conexao", originalError) {
+    super(message, void 0, void 0);
     this.name = "NetworkError";
     this.originalError = originalError;
     Object.setPrototypeOf(this, _NetworkError.prototype);
   }
-  get isRetryable() {
+  isRetryable() {
     return true;
   }
 };
+
+// src/client.ts
 var DEFAULT_RETRY_CONFIG = {
   maxRetries: 3,
-  initialDelay: 500,
-  maxDelay: 1e4,
+  initialDelay: 1e3,
+  maxDelay: 3e4,
   backoffFactor: 2,
-  retryableStatuses: [429, 500, 502, 503, 504]
+  retryableStatusCodes: [429, 500, 502, 503, 504]
 };
-var IPTUClient = class {
-  apiKey;
-  baseUrl;
-  timeout;
-  retryConfig;
-  logger;
-  logRequests;
-  logResponses;
-  userAgent;
-  _rateLimit;
-  _lastRequestId;
-  constructor(apiKey, options = {}) {
-    if (!apiKey) {
-      throw new Error("API Key \xE9 obrigat\xF3ria");
+var DEFAULT_CONFIG = {
+  baseUrl: "https://iptuapi.com.br/api/v1",
+  timeout: 3e4,
+  retryConfig: DEFAULT_RETRY_CONFIG
+};
+function toCamelCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const camelKey = key.replace(
+      /_([a-z])/g,
+      (_, letter) => letter.toUpperCase()
+    );
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[camelKey] = toCamelCase(value);
+    } else if (Array.isArray(value)) {
+      result[camelKey] = value.map(
+        (item) => typeof item === "object" && item !== null ? toCamelCase(item) : item
+      );
+    } else {
+      result[camelKey] = value;
     }
-    this.apiKey = apiKey;
-    this.baseUrl = options.baseUrl || "https://iptuapi.com.br/api/v1";
-    this.timeout = options.timeout || 3e4;
-    this.retryConfig = { ...DEFAULT_RETRY_CONFIG, ...options.retry };
-    this.logger = options.logger;
-    this.logRequests = options.logRequests || false;
-    this.logResponses = options.logResponses || false;
-    this.userAgent = options.userAgent || "iptuapi-js/2.0.0";
-  }
-  // ===========================================================================
-  // Properties
-  // ===========================================================================
-  /** Rate limit info from last request */
-  get rateLimit() {
-    return this._rateLimit;
-  }
-  /** Request ID from last request (useful for support) */
-  get lastRequestId() {
-    return this._lastRequestId;
   }
-  // ===========================================================================
-  // Private Methods
-  // ===========================================================================
-  log(level, message, ...args) {
-    if (this.logger && this.logger[level]) {
-      this.logger[level](message, ...args);
+  return result;
+}
+function toSnakeCase(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const snakeKey = key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[snakeKey] = toSnakeCase(value);
+    } else if (Array.isArray(value)) {
+      result[snakeKey] = value.map(
+        (item) => typeof item === "object" && item !== null ? toSnakeCase(item) : item
+      );
+    } else {
+      result[snakeKey] = value;
     }
   }
-  sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-  }
-  calculateDelay(attempt) {
-    const delay = this.retryConfig.initialDelay * Math.pow(this.retryConfig.backoffFactor, attempt);
-    return Math.min(delay, this.retryConfig.maxDelay);
+  return result;
+}
+var IPTUClient = class {
+  apiKey;
+  config;
+  _rateLimitInfo = null;
+  _lastRequestId = null;
+  /**
+   * Cria uma nova instancia do cliente.
+   *
+   * @param apiKey - Chave de API para autenticacao
+   * @param options - Opcoes de configuracao
+   */
+  constructor(apiKey, options) {
+    this.apiKey = apiKey;
+    this.config = {
+      baseUrl: options?.baseUrl || DEFAULT_CONFIG.baseUrl,
+      timeout: options?.timeout || DEFAULT_CONFIG.timeout,
+      retryConfig: {
+        ...DEFAULT_RETRY_CONFIG,
+        ...options?.retryConfig
+      }
+    };
   }
-  extractRateLimit(headers) {
-    const limit = headers.get("X-RateLimit-Limit");
-    const remaining = headers.get("X-RateLimit-Remaining");
-    const reset = headers.get("X-RateLimit-Reset");
-    if (limit && remaining && reset) {
-      const resetTimestamp = parseInt(reset, 10);
-      return {
-        limit: parseInt(limit, 10),
-        remaining: parseInt(remaining, 10),
-        reset: resetTimestamp,
-        resetDate: new Date(resetTimestamp * 1e3)
-      };
-    }
-    return void 0;
+  /**
+   * Retorna informacoes do rate limit da ultima requisicao.
+   */
+  get rateLimitInfo() {
+    return this._rateLimitInfo;
   }
-  async handleErrorResponse(response, requestId) {
-    let body = {};
-    try {
-      body = await response.json();
-    } catch {
-      body = { detail: response.statusText };
-    }
-    let message;
-    const detail = body.detail;
-    if (detail && typeof detail === "object") {
-      const detailObj = detail;
-      message = detailObj.error || detailObj.detail || detailObj.message || JSON.stringify(detail);
-    } else {
-      message = detail || `HTTP ${response.status}`;
-    }
-    switch (response.status) {
-      case 400:
-      case 422:
-        throw new ValidationError(
-          message,
-          body.errors,
-          requestId,
-          body
-        );
-      case 401:
-        throw new AuthenticationError(message, requestId, body);
-      case 403:
-        throw new ForbiddenError(
-          message,
-          body.required_plan,
-          requestId,
-          body
-        );
-      case 404:
-        throw new NotFoundError(message, requestId, body);
-      case 429:
-        const retryAfter = response.headers.get("Retry-After");
-        throw new RateLimitError(
-          message,
-          retryAfter ? parseInt(retryAfter, 10) : void 0,
-          this._rateLimit?.limit,
-          this._rateLimit?.remaining,
-          requestId,
-          body
-        );
-      case 500:
-      case 502:
-      case 503:
-      case 504:
-        throw new ServerError(message, response.status, requestId, body);
-      default:
-        throw new IPTUAPIError(message, response.status, requestId, body);
-    }
+  /**
+   * Retorna o ID da ultima requisicao.
+   */
+  get lastRequestId() {
+    return this._lastRequestId;
   }
-  async request(method, endpoint, params, body) {
-    const url = new URL(`${this.baseUrl}${endpoint}`);
+  /**
+   * Executa uma requisicao HTTP com retry.
+   */
+  async makeRequest(method, endpoint, params, body) {
+    const url = new URL(`${this.config.baseUrl}/${endpoint.replace(/^\//, "")}`);
     if (params) {
-      Object.entries(params).forEach(([key, value]) => {
-        if (value !== void 0 && value !== null && value !== "") {
+      for (const [key, value] of Object.entries(params)) {
+        if (value !== void 0 && value !== null) {
           url.searchParams.append(key, String(value));
         }
-      });
+      }
     }
-    const headers = {
-      "X-API-Key": this.apiKey,
-      "Content-Type": "application/json",
-      Accept: "application/json",
-      "User-Agent": this.userAgent
-    };
-    let lastError;
-    let attempt = 0;
-    while (attempt <= this.retryConfig.maxRetries) {
+    const { maxRetries, initialDelay, maxDelay, backoffFactor } = this.config.retryConfig;
+    let delay = initialDelay;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
       const controller = new AbortController();
-      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const timeoutId = setTimeout(
+        () => controller.abort(),
+        this.config.timeout
+      );
       try {
-        if (this.logRequests) {
-          this.log(
-            "debug",
-            `Request: ${method} ${url}`,
-            params ? { params } : {},
-            body ? { body } : {}
-          );
-        }
-        const startTime = Date.now();
         const response = await fetch(url.toString(), {
           method,
-          headers,
-          body: body ? JSON.stringify(body) : void 0,
+          headers: {
+            "X-API-Key": this.apiKey,
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            "User-Agent": "iptuapi-js/1.0.0"
+          },
+          body: body ? JSON.stringify(toSnakeCase(body)) : void 0,
           signal: controller.signal
         });
         clearTimeout(timeoutId);
-        const elapsedMs = Date.now() - startTime;
-        this._rateLimit = this.extractRateLimit(response.headers);
-        this._lastRequestId = response.headers.get("X-Request-ID") || void 0;
-        if (this.logResponses) {
-          this.log(
-            "debug",
-            `Response: ${response.status} ${url} (${elapsedMs}ms)`
-          );
+        this.updateRateLimitInfo(response.headers);
+        this._lastRequestId = response.headers.get("X-Request-ID");
+        if (!response.ok) {
+          await this.handleError(response);
         }
-        if (response.ok) {
-          return await response.json();
-        }
-        if (this.retryConfig.retryableStatuses.includes(response.status) && attempt < this.retryConfig.maxRetries) {
-          const delay = this.calculateDelay(attempt);
-          this.log(
-            "warn",
-            `Request failed with ${response.status}, retrying in ${delay}ms (attempt ${attempt + 1}/${this.retryConfig.maxRetries})`
-          );
-          await this.sleep(delay);
-          attempt++;
-          continue;
-        }
-        await this.handleErrorResponse(response, this._lastRequestId);
+        const data = await response.json();
+        return toCamelCase(data.data || data);
       } catch (error) {
         clearTimeout(timeoutId);
         if (error instanceof IPTUAPIError) {
+          if (error.isRetryable() && attempt < maxRetries && this.config.retryConfig.retryableStatusCodes.includes(
+            error.statusCode || 0
+          )) {
+            await this.sleep(delay);
+            delay = Math.min(delay * backoffFactor, maxDelay);
+            continue;
+          }
           throw error;
         }
         if (error instanceof Error) {
           if (error.name === "AbortError") {
-            lastError = new TimeoutError(
-              `Timeout ap\xF3s ${this.timeout}ms`,
-              this.timeout
+            if (attempt < maxRetries) {
+              await this.sleep(delay);
+              delay = Math.min(delay * backoffFactor, maxDelay);
+              continue;
+            }
+            throw new TimeoutError(
+              `Timeout apos ${this.config.timeout}ms`,
+              this.config.timeout / 1e3
             );
-          } else if (error.message.includes("fetch") || error.message.includes("network")) {
-            lastError = new NetworkError(
-              `Erro de conex\xE3o: ${error.message}`,
-              error
-            );
-          } else {
-            lastError = error;
           }
-          if (attempt < this.retryConfig.maxRetries) {
-            const delay = this.calculateDelay(attempt);
-            this.log(
-              "warn",
-              `Request failed: ${error.message}, retrying in ${delay}ms (attempt ${attempt + 1}/${this.retryConfig.maxRetries})`
-            );
+          if (attempt < maxRetries) {
             await this.sleep(delay);
-            attempt++;
+            delay = Math.min(delay * backoffFactor, maxDelay);
             continue;
           }
+          throw new NetworkError(`Erro de conexao: ${error.message}`, error);
         }
-        throw lastError || error;
+        throw new NetworkError("Erro desconhecido");
       }
     }
-    throw lastError || new IPTUAPIError("Max retries exceeded");
-  }
-  async consultaEndereco(paramsOrLogradouro, numero, cidade) {
-    let params;
-    if (typeof paramsOrLogradouro === "string") {
-      params = {
-        logradouro: paramsOrLogradouro,
-        numero,
-        cidade: cidade || "sp"
-      };
-    } else {
-      params = {
-        logradouro: paramsOrLogradouro.logradouro,
-        numero: paramsOrLogradouro.numero,
-        complemento: paramsOrLogradouro.complemento,
-        cidade: paramsOrLogradouro.cidade || "sp",
-        incluir_historico: paramsOrLogradouro.incluirHistorico,
-        incluir_comparaveis: paramsOrLogradouro.incluirComparaveis,
-        incluir_zoneamento: paramsOrLogradouro.incluirZoneamento
+    throw new NetworkError("Maximo de tentativas excedido");
+  }
+  /**
+   * Atualiza informacoes de rate limit a partir dos headers.
+   */
+  updateRateLimitInfo(headers) {
+    const limit = headers.get("X-RateLimit-Limit");
+    const remaining = headers.get("X-RateLimit-Remaining");
+    const reset = headers.get("X-RateLimit-Reset");
+    if (limit && remaining && reset) {
+      this._rateLimitInfo = {
+        limit: parseInt(limit, 10),
+        remaining: parseInt(remaining, 10),
+        resetAt: new Date(parseInt(reset, 10) * 1e3)
       };
     }
-    return this.request(
-      "GET",
-      "/consulta/endereco",
-      params
-    );
   }
   /**
-   * Busca dados de IPTU por número SQL (contribuinte).
+   * Converte resposta HTTP em excecao apropriada.
+   */
+  async handleError(response) {
+    const requestId = response.headers.get("X-Request-ID") || void 0;
+    let data = {};
+    let message = "Erro desconhecido";
+    try {
+      data = await response.json();
+      message = data.detail || data.message || message;
+    } catch {
+      message = response.statusText || message;
+    }
+    switch (response.status) {
+      case 401:
+        throw new AuthenticationError(message, requestId);
+      case 403:
+        throw new ForbiddenError(
+          message,
+          data.required_plan,
+          requestId
+        );
+      case 404:
+        throw new NotFoundError(
+          message,
+          data.resource,
+          requestId
+        );
+      case 429: {
+        const retryAfter = parseInt(
+          response.headers.get("Retry-After") || "60",
+          10
+        );
+        throw new RateLimitError(message, retryAfter, requestId);
+      }
+      case 400:
+      case 422:
+        throw new ValidationError(
+          message,
+          data.errors,
+          response.status,
+          requestId
+        );
+      default:
+        if (response.status >= 500) {
+          throw new ServerError(message, response.status, requestId);
+        }
+        throw new IPTUAPIError(message, response.status, requestId, data);
+    }
+  }
+  /**
+   * Aguarda um tempo em milissegundos.
+   */
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  // ==================== CONSULTAS IPTU ====================
+  /**
+   * Consulta imoveis por endereco.
+   *
+   * @param logradouro - Nome da rua/avenida
+   * @param numero - Numero do imovel
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Lista de imoveis encontrados
+   */
+  async consultaEndereco(logradouro, numero, cidade = "sp") {
+    const response = await this.makeRequest("GET", "/consulta/endereco", {
+      logradouro,
+      numero,
+      cidade
+    });
+    return Array.isArray(response) ? response : [];
+  }
+  /**
+   * Consulta imovel por numero SQL/Indice Cadastral.
+   * Requer plano Starter ou superior.
    *
-   * @param sql - Número SQL do imóvel
-   * @param cidade - Cidade da consulta
-   * @param options - Opções adicionais
-   * @returns Dados completos do imóvel
+   * @param sql - Numero SQL (SP), Indice Cadastral (BH) ou Sequencial (Recife)
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Lista de imoveis encontrados
    */
-  async consultaSQL(sql, cidade = "sp", options) {
-    return this.request("GET", `/consulta/sql/${sql}`, {
-      cidade,
-      incluir_historico: options?.incluirHistorico,
-      incluir_comparaveis: options?.incluirComparaveis
+  async consultaSQL(sql, cidade = "sp") {
+    const response = await this.makeRequest("GET", "/consulta/sql", {
+      sql,
+      cidade
     });
+    return Array.isArray(response) ? response : [];
   }
   /**
-   * Busca imóveis por CEP.
+   * Consulta imoveis por CEP.
    *
-   * @param cep - CEP do imóvel
-   * @param cidade - Cidade da consulta
-   * @returns Lista de imóveis no CEP
+   * @param cep - CEP do endereco
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Lista de imoveis encontrados
    */
   async consultaCEP(cep, cidade = "sp") {
-    const cleanCep = cep.replace(/\D/g, "");
-    return this.request(
-      "GET",
-      `/consulta/cep/${cleanCep}`,
-      { cidade }
-    );
+    const response = await this.makeRequest("GET", "/consulta/cep", {
+      cep,
+      cidade
+    });
+    return Array.isArray(response) ? response : [];
   }
   /**
    * Consulta zoneamento por coordenadas.
    *
    * @param latitude - Latitude do ponto
    * @param longitude - Longitude do ponto
-   * @returns Dados de zoneamento
+   * @returns Informacoes de zoneamento
    */
   async consultaZoneamento(latitude, longitude) {
-    return this.request("GET", "/consulta/zoneamento", {
-      latitude,
-      longitude
+    return this.makeRequest("GET", "/consulta/zoneamento", {
+      lat: latitude,
+      lng: longitude
     });
   }
-  // ===========================================================================
-  // Valuation Endpoints (Pro+)
-  // ===========================================================================
+  // ==================== VALUATION ====================
   /**
-   * Estima o valor de mercado do imóvel usando ML.
-   * Disponível apenas para planos Pro e Enterprise.
+   * Calcula estimativa de valor de mercado.
+   * Requer plano Pro ou superior.
    *
-   * @param params - Parâmetros do imóvel
-   * @returns Estimativa de valor
-   * @throws {ForbiddenError} Se o plano não permitir
+   * @param params - Parametros da avaliacao
+   * @returns Avaliacao de mercado
    */
   async valuationEstimate(params) {
-    return this.request(
-      "POST",
-      "/valuation/estimate",
-      void 0,
+    return this.makeRequest("GET", "/valuation/estimate", {
+      area_terreno: params.areaTerreno,
+      area_construida: params.areaConstruida,
+      bairro: params.bairro,
+      cidade: params.cidade || "sp",
+      zona: params.zona,
+      tipo_uso: params.tipoUso,
+      tipo_padrao: params.tipoPadrao,
+      ano_construcao: params.anoConstrucao
+    });
+  }
+  /**
+   * Busca imoveis comparaveis.
+   * Requer plano Pro ou superior.
+   *
+   * @param params - Parametros da busca
+   * @returns Lista de imoveis comparaveis
+   */
+  async valuationComparables(params) {
+    const response = await this.makeRequest(
+      "GET",
+      "/valuation/comparables",
       {
-        area_terreno: params.area_terreno,
-        area_construida: params.area_construida,
         bairro: params.bairro,
-        zona: params.zona,
-        tipo_uso: params.tipo_uso,
-        tipo_padrao: params.tipo_padrao,
-        ano_construcao: params.ano_construcao,
-        cidade: params.cidade || "sp"
+        area_min: params.areaMin,
+        area_max: params.areaMax,
+        cidade: params.cidade || "sp",
+        limit: params.limit || 10
       }
     );
+    return Array.isArray(response) ? response : [];
   }
   /**
-   * Valuation em lote (até 100 imóveis).
-   * Disponível apenas para plano Enterprise.
+   * Avalia imovel por endereco OU SQL.
+   * Combina dados do modelo AVM (ML) com transacoes ITBI reais.
+   * Requer plano Pro ou superior.
    *
-   * @param imoveis - Lista de imóveis para avaliar
-   * @returns Resultados de valuation para cada imóvel
+   * @param params - Parametros da avaliacao (sql OU logradouro+numero)
+   * @returns Avaliacao completa do imovel
    */
-  async valuationBatch(imoveis) {
-    return this.request(
+  async valuationEvaluate(params) {
+    const body = {
+      cidade: params.cidade || "sp",
+      incluirItbi: params.incluirItbi ?? true,
+      incluirComparaveis: params.incluirComparaveis ?? true
+    };
+    if (params.sql) {
+      body.sql = params.sql;
+    } else {
+      if (params.logradouro) body.logradouro = params.logradouro;
+      if (params.numero !== void 0) body.numero = params.numero;
+      if (params.complemento) body.complemento = params.complemento;
+      if (params.bairro) body.bairro = params.bairro;
+    }
+    return this.makeRequest(
       "POST",
-      "/valuation/estimate/batch",
+      "/valuation/evaluate",
       void 0,
-      { imoveis }
+      body
     );
   }
+  // ==================== ITBI ====================
   /**
-   * Busca imóveis comparáveis para análise.
+   * Consulta status de transacao ITBI.
    *
-   * @param bairro - Nome do bairro
-   * @param areaMin - Área mínima em m²
-   * @param areaMax - Área máxima em m²
-   * @param options - Opções adicionais
-   * @returns Lista de imóveis comparáveis
+   * @param protocolo - Numero do protocolo ITBI
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Status da transacao
    */
-  async valuationComparables(bairro, areaMin, areaMax, options) {
-    return this.request("GET", "/valuation/comparables", {
-      bairro,
-      area_min: areaMin,
-      area_max: areaMax,
-      tipo_uso: options?.tipoUso,
-      cidade: options?.cidade || "sp",
-      limit: options?.limit || 10
+  async itbiStatus(protocolo, cidade = "sp") {
+    return this.makeRequest("GET", "/itbi/status", {
+      protocolo,
+      cidade
     });
   }
-  // ===========================================================================
-  // Dados Endpoints
-  // ===========================================================================
   /**
-   * Histórico de valores IPTU de um imóvel.
+   * Calcula valor do ITBI.
    *
-   * @param sql - Número SQL do imóvel
-   * @param cidade - Cidade da consulta
-   * @returns Lista com histórico anual
+   * @param params - Parametros do calculo
+   * @returns Calculo do ITBI
    */
-  async dadosIPTUHistorico(sql, cidade = "sp") {
-    return this.request(
-      "GET",
-      `/dados/iptu/historico/${sql}`,
-      { cidade }
-    );
+  async itbiCalcular(params) {
+    return this.makeRequest("POST", "/itbi/calcular", void 0, {
+      sql: params.sql,
+      valorTransacao: params.valorTransacao,
+      cidade: params.cidade || "sp"
+    });
   }
   /**
-   * Consulta dados de empresa por CNPJ.
+   * Consulta historico de transacoes ITBI de um imovel.
+   * Requer plano Starter ou superior.
    *
-   * @param cnpj - CNPJ da empresa
-   * @returns Dados cadastrais
+   * @param sql - Numero SQL do imovel
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Lista de transacoes historicas
    */
-  async dadosCNPJ(cnpj) {
-    const cleanCnpj = cnpj.replace(/\D/g, "");
-    return this.request(
+  async itbiHistorico(sql, cidade = "sp") {
+    const response = await this.makeRequest(
       "GET",
-      `/dados/cnpj/${cleanCnpj}`
+      "/itbi/historico",
+      { sql, cidade }
     );
+    return Array.isArray(response) ? response : [];
   }
   /**
-   * Correção monetária pelo IPCA.
+   * Consulta aliquotas ITBI vigentes.
    *
-   * @param valor - Valor a corrigir
-   * @param dataOrigem - Data do valor original (YYYY-MM)
-   * @param dataDestino - Data destino (default: atual)
-   * @returns Valor corrigido e fator de correção
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Aliquotas vigentes
    */
-  async dadosIPCACorrigir(valor, dataOrigem, dataDestino) {
-    return this.request(
+  async itbiAliquotas(cidade = "sp") {
+    return this.makeRequest("GET", "/itbi/aliquotas", { cidade });
+  }
+  /**
+   * Consulta isencoes ITBI disponiveis.
+   *
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Lista de isencoes disponiveis
+   */
+  async itbiIsencoes(cidade = "sp") {
+    const response = await this.makeRequest(
       "GET",
-      "/dados/ipca/corrigir",
-      {
-        valor,
-        data_origem: dataOrigem,
-        data_destino: dataDestino
-      }
+      "/itbi/isencoes",
+      { cidade }
     );
+    return Array.isArray(response) ? response : [];
+  }
+  /**
+   * Gera guia de pagamento ITBI.
+   * Requer plano Starter ou superior.
+   *
+   * @param params - Parametros da guia
+   * @returns Guia de pagamento gerada
+   */
+  async itbiGuia(params) {
+    return this.makeRequest("POST", "/itbi/guia", void 0, {
+      sql: params.sql,
+      valorTransacao: params.valorTransacao,
+      comprador: params.comprador,
+      vendedor: params.vendedor,
+      cidade: params.cidade || "sp"
+    });
+  }
+  /**
+   * Valida autenticidade de uma guia ITBI.
+   *
+   * @param protocolo - Numero do protocolo da guia
+   * @param cidade - Codigo da cidade (sp, bh, recife)
+   * @returns Resultado da validacao
+   */
+  async itbiValidarGuia(protocolo, cidade = "sp") {
+    return this.makeRequest("GET", "/itbi/validar", {
+      protocolo,
+      cidade
+    });
+  }
+  /**
+   * Simula calculo de ITBI.
+   *
+   * @param params - Parametros da simulacao
+   * @returns Resultado da simulacao
+   */
+  async itbiSimular(params) {
+    return this.makeRequest("POST", "/itbi/simular", void 0, {
+      valorTransacao: params.valorTransacao,
+      cidade: params.cidade || "sp",
+      tipoFinanciamento: params.tipoFinanciamento,
+      valorFinanciado: params.valorFinanciado
+    });
   }
 };
-var index_default = IPTUClient;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthenticationError,
-  CidadeEnum,
   ForbiddenError,
   IPTUAPIError,
   IPTUClient,