@f-o-t/brasil-api 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1442 @@
+/**
+* Configuration for Brasil API client
+*/
+interface BrasilApiConfig {
+	baseUrl: string;
+	timeout: number;
+}
+/**
+* Get current configuration
+*/
+declare function getConfig(): BrasilApiConfig;
+/**
+* Configure Brasil API client
+* @param config Partial configuration to merge with defaults
+*/
+declare function configureBrasilApi(config: Partial<BrasilApiConfig>): void;
+/**
+* Set custom configuration (alias for configureBrasilApi)
+* @param config Partial configuration to merge with defaults
+*/
+declare function setConfig(config: Partial<BrasilApiConfig>): void;
+/**
+* Reset configuration to defaults
+*/
+declare function resetConfig(): void;
+import { ZodError } from "zod";
+/**
+* Base error class for Brasil API errors
+*/
+declare class BrasilApiError extends Error {
+	constructor(message: string);
+}
+/**
+* Network-related errors (fetch failures, timeouts, HTTP errors)
+*/
+declare class BrasilApiNetworkError extends BrasilApiError {
+	readonly statusCode?: number;
+	readonly endpoint: string;
+	constructor(message: string, statusCode: number | undefined, endpoint: string);
+}
+/**
+* Validation errors (input or response validation failures)
+*/
+declare class BrasilApiValidationError extends BrasilApiError {
+	readonly zodError: ZodError;
+	readonly validationType: "input" | "response";
+	constructor(message: string, zodError: ZodError, validationType: "input" | "response");
+}
+/**
+* Response validation errors (invalid API response)
+*/
+declare class BrasilApiResponseError extends BrasilApiValidationError {
+	constructor(message: string, zodError: ZodError);
+}
+import { z } from "zod";
+/**
+* CEP response schema (v1)
+*/
+declare const CepResponseSchema: z.ZodObject<{
+	cep: z.ZodString;
+	state: z.ZodString;
+	city: z.ZodString;
+	neighborhood: z.ZodString;
+	street: z.ZodString;
+	service: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+	cep?: string;
+	state?: string;
+	city?: string;
+	neighborhood?: string;
+	street?: string;
+	service?: string;
+}, {
+	cep?: string;
+	state?: string;
+	city?: string;
+	neighborhood?: string;
+	street?: string;
+	service?: string;
+}>;
+/**
+* CEP response type (v1)
+*/
+type CepResponse = z.infer<typeof CepResponseSchema>;
+/**
+* CEP response schema (v2 with coordinates)
+*/
+declare const CepV2ResponseSchema: z.ZodObject<{
+	cep: z.ZodString;
+	state: z.ZodString;
+	city: z.ZodString;
+	neighborhood: z.ZodString;
+	street: z.ZodString;
+	service: z.ZodString;
+} & {
+	location: z.ZodObject<{
+		type: z.ZodLiteral<"Point">;
+		coordinates: z.ZodObject<{
+			longitude: z.ZodString;
+			latitude: z.ZodString;
+		}, "strip", z.ZodTypeAny, {
+			longitude?: string;
+			latitude?: string;
+		}, {
+			longitude?: string;
+			latitude?: string;
+		}>;
+	}, "strip", z.ZodTypeAny, {
+		type?: "Point";
+		coordinates?: {
+			longitude?: string;
+			latitude?: string;
+		};
+	}, {
+		type?: "Point";
+		coordinates?: {
+			longitude?: string;
+			latitude?: string;
+		};
+	}>;
+}, "strip", z.ZodTypeAny, {
+	cep?: string;
+	state?: string;
+	city?: string;
+	neighborhood?: string;
+	street?: string;
+	service?: string;
+	location?: {
+		type?: "Point";
+		coordinates?: {
+			longitude?: string;
+			latitude?: string;
+		};
+	};
+}, {
+	cep?: string;
+	state?: string;
+	city?: string;
+	neighborhood?: string;
+	street?: string;
+	service?: string;
+	location?: {
+		type?: "Point";
+		coordinates?: {
+			longitude?: string;
+			latitude?: string;
+		};
+	};
+}>;
+/**
+* CEP response type (v2)
+*/
+type CepV2Response = z.infer<typeof CepV2ResponseSchema>;
+/**
+* Get address information by CEP (postal code)
+* @param cep CEP in format 12345-678 or 12345678
+* @returns Address data
+* @throws {BrasilApiValidationError} On invalid input
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*/
+declare function getCep(cep: string): Promise<CepResponse>;
+/**
+* Get address information with geolocation by CEP
+* @param cep CEP in format 12345-678 or 12345678
+* @returns Address data with latitude/longitude
+* @throws {BrasilApiValidationError} On invalid input
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*/
+declare function getCepV2(cep: string): Promise<CepV2Response>;
+import { z as z2 } from "zod";
+/**
+* Bank response schema
+*/
+declare const BankSchema: z2.ZodObject<{
+	ispb: z2.ZodString;
+	name: z2.ZodString;
+	code: z2.ZodNullable<z2.ZodNumber>;
+	fullName: z2.ZodString;
+}, "strip", z2.ZodTypeAny, {
+	ispb?: string;
+	name?: string;
+	code?: number;
+	fullName?: string;
+}, {
+	ispb?: string;
+	name?: string;
+	code?: number;
+	fullName?: string;
+}>;
+/**
+* Bank type
+*/
+type Bank = z2.infer<typeof BankSchema>;
+/**
+* Get all Brazilian banks
+* @returns Array of all banks
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*/
+declare function getBanks(): Promise<Bank[]>;
+/**
+* Get bank information by code
+* @param code Bank code (e.g., 1 for Banco do Brasil)
+* @returns Bank data
+* @throws {BrasilApiValidationError} On invalid input
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*/
+declare function getBank(code: number): Promise<Bank>;
+import { z as z3 } from "zod";
+/**
+* CNPJ response schema
+*/
+declare const CnpjResponseSchema: z3.ZodObject<{
+	cnpj: z3.ZodString;
+	razao_social: z3.ZodOptional<z3.ZodString>;
+	nome_fantasia: z3.ZodOptional<z3.ZodString>;
+	uf: z3.ZodOptional<z3.ZodString>;
+	municipio: z3.ZodOptional<z3.ZodString>;
+	natureza_juridica: z3.ZodOptional<z3.ZodString>;
+	situacao_cadastral: z3.ZodOptional<z3.ZodString>;
+	data_inicio_atividade: z3.ZodOptional<z3.ZodString>;
+	cnae_fiscal: z3.ZodOptional<z3.ZodString>;
+	qsa: z3.ZodArray<z3.ZodAny, "many">;
+}, "strip", z3.ZodTypeAny, {
+	cnpj?: string;
+	razao_social?: string;
+	nome_fantasia?: string;
+	uf?: string;
+	municipio?: string;
+	natureza_juridica?: string;
+	situacao_cadastral?: string;
+	data_inicio_atividade?: string;
+	cnae_fiscal?: string;
+	qsa?: any[];
+}, {
+	cnpj?: string;
+	razao_social?: string;
+	nome_fantasia?: string;
+	uf?: string;
+	municipio?: string;
+	natureza_juridica?: string;
+	situacao_cadastral?: string;
+	data_inicio_atividade?: string;
+	cnae_fiscal?: string;
+	qsa?: any[];
+}>;
+/**
+* CNPJ response type
+*/
+type CnpjResponse = z3.infer<typeof CnpjResponseSchema>;
+/**
+* Get company information by CNPJ
+* @param cnpj CNPJ with or without punctuation (12.345.678/0001-90 or 12345678000190)
+* @returns Company data
+* @throws {BrasilApiValidationError} On invalid input
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*/
+declare function getCnpj(cnpj: string): Promise<CnpjResponse>;
+import { z as z4 } from "zod";
+/**
+* DDD response schema
+*/
+declare const DddResponseSchema: z4.ZodObject<{
+	state: z4.ZodString;
+	cities: z4.ZodArray<z4.ZodString, "many">;
+}, "strip", z4.ZodTypeAny, {
+	state?: string;
+	cities?: string[];
+}, {
+	state?: string;
+	cities?: string[];
+}>;
+/**
+* DDD response type
+*/
+type DddResponse = z4.infer<typeof DddResponseSchema>;
+/**
+* Get cities by area code (DDD)
+* @param ddd Area code (2 digits)
+* @returns State and list of cities
+* @throws {BrasilApiValidationError} On invalid input
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*/
+declare function getDdd(ddd: number | string): Promise<DddResponse>;
+import { z as z5 } from "zod";
+/**
+* Schema for a single holiday (feriado)
+*/
+declare const FeriadoSchema: z5.ZodObject<{
+	date: z5.ZodString;
+	name: z5.ZodString;
+	type: z5.ZodString;
+}, "strip", z5.ZodTypeAny, {
+	name?: string;
+	type?: string;
+	date?: string;
+}, {
+	name?: string;
+	type?: string;
+	date?: string;
+}>;
+/**
+* Type for a Brazilian national holiday
+*/
+type Feriado = z5.infer<typeof FeriadoSchema>;
+/**
+* Get Brazilian national holidays for a given year
+*
+* @param year - Year to get holidays for (must be between 1900 and 2199)
+* @returns Array of holidays with date, name, and type
+* @throws {BrasilApiValidationError} If year is invalid
+*
+* @example
+* ```typescript
+* const holidays = await getFeriados(2024);
+* console.log(holidays);
+* // [
+* //   { date: "2024-01-01", name: "Confraternização mundial", type: "national" },
+* //   { date: "2024-04-21", name: "Tiradentes", type: "national" },
+* //   ...
+* // ]
+* ```
+*/
+declare function getFeriados(year: number): Promise<Feriado[]>;
+import { z as z6 } from "zod";
+/**
+* Schema for a Brazilian state (estado)
+*/
+declare const EstadoSchema: z6.ZodObject<{
+	id: z6.ZodNumber;
+	sigla: z6.ZodString;
+	nome: z6.ZodString;
+	regiao: z6.ZodObject<{
+		id: z6.ZodNumber;
+		sigla: z6.ZodString;
+		nome: z6.ZodString;
+	}, "strip", z6.ZodTypeAny, {
+		nome?: string;
+		id?: number;
+		sigla?: string;
+	}, {
+		nome?: string;
+		id?: number;
+		sigla?: string;
+	}>;
+}, "strip", z6.ZodTypeAny, {
+	nome?: string;
+	id?: number;
+	sigla?: string;
+	regiao?: {
+		nome?: string;
+		id?: number;
+		sigla?: string;
+	};
+}, {
+	nome?: string;
+	id?: number;
+	sigla?: string;
+	regiao?: {
+		nome?: string;
+		id?: number;
+		sigla?: string;
+	};
+}>;
+/**
+* Type for a Brazilian state
+*/
+type Estado = z6.infer<typeof EstadoSchema>;
+/**
+* Schema for a Brazilian municipality (municipio)
+*/
+declare const MunicipioSchema: z6.ZodObject<{
+	nome: z6.ZodString;
+	codigo_ibge: z6.ZodString;
+}, "strip", z6.ZodTypeAny, {
+	nome?: string;
+	codigo_ibge?: string;
+}, {
+	nome?: string;
+	codigo_ibge?: string;
+}>;
+/**
+* Type for a Brazilian municipality
+*/
+type Municipio = z6.infer<typeof MunicipioSchema>;
+/**
+* Get all Brazilian states
+*
+* @returns Array of states with id, sigla, nome, and regiao
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const estados = await getEstados();
+* console.log(estados);
+* // [
+* //   {
+* //     id: 35,
+* //     sigla: "SP",
+* //     nome: "São Paulo",
+* //     regiao: { id: 3, sigla: "SE", nome: "Sudeste" }
+* //   },
+* //   ...
+* // ]
+* ```
+*/
+declare function getEstados(): Promise<Estado[]>;
+/**
+* Get municipalities by state code
+*
+* @param uf - State code (2 letters, case-insensitive)
+* @returns Array of municipalities with nome and codigo_ibge
+* @throws {BrasilApiValidationError} If state code is invalid
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const municipios = await getMunicipios("SP");
+* console.log(municipios);
+* // [
+* //   { nome: "São Paulo", codigo_ibge: "3550308" },
+* //   { nome: "Campinas", codigo_ibge: "3509502" },
+* //   ...
+* // ]
+* ```
+*/
+declare function getMunicipios(uf: string): Promise<Municipio[]>;
+import { z as z7 } from "zod";
+/**
+* Schema for ISBN response
+*/
+declare const IsbnResponseSchema: z7.ZodObject<{
+	isbn: z7.ZodString;
+	title: z7.ZodString;
+	subtitle: z7.ZodNullable<z7.ZodString>;
+	authors: z7.ZodArray<z7.ZodString, "many">;
+	publisher: z7.ZodString;
+	synopsis: z7.ZodNullable<z7.ZodString>;
+	dimensions: z7.ZodNullable<z7.ZodObject<{}, "passthrough", z7.ZodTypeAny, z7.objectOutputType<{}, z7.ZodTypeAny, "passthrough">, z7.objectInputType<{}, z7.ZodTypeAny, "passthrough">>>;
+	year: z7.ZodNullable<z7.ZodNumber>;
+	format: z7.ZodString;
+	page_count: z7.ZodNumber;
+	subjects: z7.ZodArray<z7.ZodString, "many">;
+	location: z7.ZodNullable<z7.ZodString>;
+	retail_price: z7.ZodNullable<z7.ZodString>;
+	cover_url: z7.ZodNullable<z7.ZodString>;
+	provider: z7.ZodString;
+}, "strip", z7.ZodTypeAny, {
+	location?: string;
+	isbn?: string;
+	title?: string;
+	subtitle?: string;
+	authors?: string[];
+	publisher?: string;
+	synopsis?: string;
+	dimensions?: {} & {
+		[k: string]: unknown;
+	};
+	year?: number;
+	format?: string;
+	page_count?: number;
+	subjects?: string[];
+	retail_price?: string;
+	cover_url?: string;
+	provider?: string;
+}, {
+	location?: string;
+	isbn?: string;
+	title?: string;
+	subtitle?: string;
+	authors?: string[];
+	publisher?: string;
+	synopsis?: string;
+	dimensions?: {} & {
+		[k: string]: unknown;
+	};
+	year?: number;
+	format?: string;
+	page_count?: number;
+	subjects?: string[];
+	retail_price?: string;
+	cover_url?: string;
+	provider?: string;
+}>;
+/**
+* Type for ISBN response
+*/
+type IsbnResponse = z7.infer<typeof IsbnResponseSchema>;
+/**
+* Get book information by ISBN
+*
+* @param isbn - ISBN code (10 or 13 digits)
+* @returns Book information including title, authors, publisher, etc.
+* @throws {BrasilApiValidationError} If ISBN format is invalid
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const book = await getIsbn("9788545702269");
+* console.log(book.title);
+* console.log(book.authors);
+* ```
+*/
+declare function getIsbn(isbn: string): Promise<IsbnResponse>;
+import { z as z8 } from "zod";
+/**
+* Schema for NCM (Nomenclatura Comum do Mercosul)
+*/
+declare const NcmSchema: z8.ZodObject<{
+	codigo: z8.ZodString;
+	descricao: z8.ZodString;
+	data_inicio: z8.ZodString;
+	data_fim: z8.ZodString;
+	tipo_ato: z8.ZodString;
+	numero_ato: z8.ZodString;
+	ano_ato: z8.ZodString;
+}, "strip", z8.ZodTypeAny, {
+	codigo?: string;
+	descricao?: string;
+	data_inicio?: string;
+	data_fim?: string;
+	tipo_ato?: string;
+	numero_ato?: string;
+	ano_ato?: string;
+}, {
+	codigo?: string;
+	descricao?: string;
+	data_inicio?: string;
+	data_fim?: string;
+	tipo_ato?: string;
+	numero_ato?: string;
+	ano_ato?: string;
+}>;
+/**
+* Type for NCM
+*/
+type Ncm = z8.infer<typeof NcmSchema>;
+/**
+* Get all NCM codes
+*
+* @returns Array of NCM codes with descriptions and metadata
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const ncms = await getNcms();
+* console.log(ncms);
+* // [
+* //   {
+* //     codigo: "01012100",
+* //     descricao: "Reprodutores de raça pura",
+* //     data_inicio: "2017-01-01",
+* //     data_fim: "2023-03-31",
+* //     tipo_ato: "Res Camex",
+* //     numero_ato: "125",
+* //     ano_ato: "2016"
+* //   },
+* //   ...
+* // ]
+* ```
+*/
+declare function getNcms(): Promise<Ncm[]>;
+/**
+* Get NCM by code
+*
+* @param code - NCM code (8 digits)
+* @returns NCM information with description and metadata
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const ncm = await getNcm("01012100");
+* console.log(ncm);
+* // {
+* //   codigo: "01012100",
+* //   descricao: "Reprodutores de raça pura",
+* //   data_inicio: "2017-01-01",
+* //   data_fim: "2023-03-31",
+* //   tipo_ato: "Res Camex",
+* //   numero_ato: "125",
+* //   ano_ato: "2016"
+* // }
+* ```
+*/
+declare function getNcm(code: string): Promise<Ncm>;
+import { z as z9 } from "zod";
+/**
+* Schema for PIX participant
+*/
+declare const PixParticipantSchema: z9.ZodObject<{
+	ispb: z9.ZodString;
+	nome: z9.ZodString;
+	nome_reduzido: z9.ZodString;
+	modalidade_participacao: z9.ZodString;
+	tipo_participacao: z9.ZodString;
+	inicio_operacao: z9.ZodString;
+}, "strip", z9.ZodTypeAny, {
+	ispb?: string;
+	nome?: string;
+	nome_reduzido?: string;
+	modalidade_participacao?: string;
+	tipo_participacao?: string;
+	inicio_operacao?: string;
+}, {
+	ispb?: string;
+	nome?: string;
+	nome_reduzido?: string;
+	modalidade_participacao?: string;
+	tipo_participacao?: string;
+	inicio_operacao?: string;
+}>;
+/**
+* Type for PIX participant
+*/
+type PixParticipant = z9.infer<typeof PixParticipantSchema>;
+/**
+* Get all PIX participants
+*
+* @returns Array of PIX participants with ISPB, names, and participation info
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const participants = await getPixParticipants();
+* console.log(participants);
+* // [
+* //   {
+* //     ispb: "00000000",
+* //     nome: "Banco Central do Brasil",
+* //     nome_reduzido: "BCB",
+* //     modalidade_participacao: "DIRETO",
+* //     tipo_participacao: "LIQUIDANTE",
+* //     inicio_operacao: "2020-11-03T00:00:00.000Z"
+* //   },
+* //   ...
+* // ]
+* ```
+*/
+declare function getPixParticipants(): Promise<PixParticipant[]>;
+import { z as z10 } from "zod";
+/**
+* Schema for domain status from Registro.br
+*/
+declare const DomainStatusSchema: z10.ZodObject<{
+	status_code: z10.ZodNumber;
+	status: z10.ZodString;
+	fqdn: z10.ZodString;
+	hosts: z10.ZodArray<z10.ZodString, "many">;
+	"publication-status": z10.ZodString;
+	"expires-at": z10.ZodString;
+	suggestions: z10.ZodArray<z10.ZodString, "many">;
+}, "strip", z10.ZodTypeAny, {
+	status?: string;
+	status_code?: number;
+	fqdn?: string;
+	hosts?: string[];
+	"publication-status"?: string;
+	"expires-at"?: string;
+	suggestions?: string[];
+}, {
+	status?: string;
+	status_code?: number;
+	fqdn?: string;
+	hosts?: string[];
+	"publication-status"?: string;
+	"expires-at"?: string;
+	suggestions?: string[];
+}>;
+/**
+* Type for domain status from Registro.br
+*/
+type DomainStatus = z10.infer<typeof DomainStatusSchema>;
+/**
+* Get status of a .br domain from Registro.br
+*
+* @param domain - The .br domain to check (e.g., "google.com.br")
+* @returns Domain status information including availability, hosts, and
+* expiration
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const status = await getDomainStatus("google.com.br");
+* console.log(status);
+* // {
+* //   status_code: 1,
+* //   status: "REGISTERED",
+* //   fqdn: "google.com.br",
+* //   hosts: ["ns1.google.com", "ns2.google.com"],
+* //   publication_status: "published",
+* //   expires_at: "2025-12-31T23:59:59.000Z",
+* //   suggestions: []
+* // }
+* ```
+*/
+declare function getDomainStatus(domain: string): Promise<DomainStatus>;
+import { z as z11 } from "zod";
+/**
+* Schema for interest rate (Taxa)
+*/
+declare const TaxaSchema: z11.ZodObject<{
+	nome: z11.ZodString;
+	valor: z11.ZodNullable<z11.ZodNumber>;
+}, "strip", z11.ZodTypeAny, {
+	nome?: string;
+	valor?: number;
+}, {
+	nome?: string;
+	valor?: number;
+}>;
+/**
+* Type for interest rate (Taxa)
+*/
+type Taxa = z11.infer<typeof TaxaSchema>;
+/**
+* Get all Brazilian interest rates
+*
+* @returns Array of interest rates with names and values
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const rates = await getTaxas();
+* console.log(rates);
+* // [
+* //   { nome: "SELIC", valor: 13.75 },
+* //   { nome: "CDI", valor: 13.65 },
+* //   { nome: "IPCA", valor: 4.62 },
+* //   ...
+* // ]
+* ```
+*/
+declare function getTaxas(): Promise<Taxa[]>;
+/**
+* Get a specific Brazilian interest rate by name/sigla
+*
+* @param sigla - The rate identifier/name (e.g., "SELIC", "CDI", "IPCA")
+* @returns Interest rate with name and value
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+* @throws {BrasilApiNotFoundError} If rate not found
+*
+* @example
+* ```typescript
+* const rate = await getTaxa("SELIC");
+* console.log(rate);
+* // { nome: "SELIC", valor: 13.75 }
+* ```
+*/
+declare function getTaxa(sigla: string): Promise<Taxa>;
+import { z as z12 } from "zod";
+/**
+* Schema for broker (Corretora) from CVM
+*/
+declare const CorretoraSchema: z12.ZodObject<{
+	cnpj: z12.ZodString;
+	type: z12.ZodString;
+	nome_social: z12.ZodString;
+	nome_comercial: z12.ZodString;
+	status: z12.ZodString;
+	email: z12.ZodOptional<z12.ZodString>;
+	telefone: z12.ZodOptional<z12.ZodString>;
+	cep: z12.ZodOptional<z12.ZodString>;
+	pais: z12.ZodOptional<z12.ZodString>;
+	uf: z12.ZodOptional<z12.ZodString>;
+	municipio: z12.ZodOptional<z12.ZodString>;
+	bairro: z12.ZodOptional<z12.ZodString>;
+	complemento: z12.ZodOptional<z12.ZodString>;
+	logradouro: z12.ZodOptional<z12.ZodString>;
+	data_patrimonio_liquido: z12.ZodOptional<z12.ZodString>;
+	valor_patrimonio_liquido: z12.ZodOptional<z12.ZodString>;
+	codigo_cvm: z12.ZodOptional<z12.ZodString>;
+	data_inicio_situacao: z12.ZodOptional<z12.ZodString>;
+	data_registro: z12.ZodOptional<z12.ZodString>;
+}, "strip", z12.ZodTypeAny, {
+	type?: string;
+	status?: string;
+	cep?: string;
+	cnpj?: string;
+	uf?: string;
+	municipio?: string;
+	nome_social?: string;
+	nome_comercial?: string;
+	email?: string;
+	telefone?: string;
+	pais?: string;
+	bairro?: string;
+	complemento?: string;
+	logradouro?: string;
+	data_patrimonio_liquido?: string;
+	valor_patrimonio_liquido?: string;
+	codigo_cvm?: string;
+	data_inicio_situacao?: string;
+	data_registro?: string;
+}, {
+	type?: string;
+	status?: string;
+	cep?: string;
+	cnpj?: string;
+	uf?: string;
+	municipio?: string;
+	nome_social?: string;
+	nome_comercial?: string;
+	email?: string;
+	telefone?: string;
+	pais?: string;
+	bairro?: string;
+	complemento?: string;
+	logradouro?: string;
+	data_patrimonio_liquido?: string;
+	valor_patrimonio_liquido?: string;
+	codigo_cvm?: string;
+	data_inicio_situacao?: string;
+	data_registro?: string;
+}>;
+/**
+* Type for broker (Corretora) from CVM
+*/
+type Corretora = z12.infer<typeof CorretoraSchema>;
+/**
+* Get all Brazilian brokers registered with CVM
+*
+* @returns Array of brokers with CNPJ, names, status, and contact
+* information
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const brokers = await getCorretoras();
+* console.log(brokers);
+* // [
+* //   {
+* //     cnpj: "00000000000000",
+* //     tipo: "Corretora de Valores",
+* //     nome_social: "Broker S.A.",
+* //     nome_comercial: "Broker",
+* //     status: "EM FUNCIONAMENTO NORMAL",
+* //     email: "contact@broker.com",
+* //     telefone: "11999999999",
+* //     ...
+* //   },
+* //   ...
+* // ]
+* ```
+*/
+declare function getCorretoras(): Promise<Corretora[]>;
+/**
+* Get a specific Brazilian broker by CNPJ from CVM
+*
+* @param cnpj - The broker's CNPJ (14 digits)
+* @returns Broker information with CNPJ, names, status, and contact
+* information
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+* @throws {BrasilApiNotFoundError} If broker not found
+*
+* @example
+* ```typescript
+* const broker = await getCorretora("00000000000000");
+* console.log(broker);
+* // {
+* //   cnpj: "00000000000000",
+* //   tipo: "Corretora de Valores",
+* //   nome_social: "Broker S.A.",
+* //   nome_comercial: "Broker",
+* //   status: "EM FUNCIONAMENTO NORMAL",
+* //   email: "contact@broker.com",
+* //   telefone: "11999999999",
+* //   ...
+* // }
+* ```
+*/
+declare function getCorretora(cnpj: string): Promise<Corretora>;
+import { z as z13 } from "zod";
+/**
+* Schema for city information from CPTEC
+*/
+declare const CidadeSchema: z13.ZodObject<{
+	id: z13.ZodNumber;
+	nome: z13.ZodString;
+	estado: z13.ZodString;
+}, "strip", z13.ZodTypeAny, {
+	nome?: string;
+	id?: number;
+	estado?: string;
+}, {
+	nome?: string;
+	id?: number;
+	estado?: string;
+}>;
+/**
+* Type for city from CPTEC
+*/
+type Cidade = z13.infer<typeof CidadeSchema>;
+/**
+* Schema for weather forecast
+*/
+declare const PrevisaoSchema: z13.ZodObject<{
+	cidade: z13.ZodString;
+	estado: z13.ZodString;
+	atualizado_em: z13.ZodString;
+	clima: z13.ZodArray<z13.ZodObject<{
+		data: z13.ZodString;
+		condicao: z13.ZodString;
+		condicao_desc: z13.ZodOptional<z13.ZodString>;
+		min: z13.ZodNumber;
+		max: z13.ZodNumber;
+		indice_uv: z13.ZodNumber;
+	}, "strip", z13.ZodTypeAny, {
+		data?: string;
+		condicao?: string;
+		condicao_desc?: string;
+		min?: number;
+		max?: number;
+		indice_uv?: number;
+	}, {
+		data?: string;
+		condicao?: string;
+		condicao_desc?: string;
+		min?: number;
+		max?: number;
+		indice_uv?: number;
+	}>, "many">;
+}, "strip", z13.ZodTypeAny, {
+	estado?: string;
+	cidade?: string;
+	atualizado_em?: string;
+	clima?: {
+		data?: string;
+		condicao?: string;
+		condicao_desc?: string;
+		min?: number;
+		max?: number;
+		indice_uv?: number;
+	}[];
+}, {
+	estado?: string;
+	cidade?: string;
+	atualizado_em?: string;
+	clima?: {
+		data?: string;
+		condicao?: string;
+		condicao_desc?: string;
+		min?: number;
+		max?: number;
+		indice_uv?: number;
+	}[];
+}>;
+/**
+* Type for weather forecast
+*/
+type Previsao = z13.infer<typeof PrevisaoSchema>;
+/**
+* Schema for ocean wave forecast
+*/
+declare const PrevisaoOndasSchema: z13.ZodObject<{
+	cidade: z13.ZodString;
+	estado: z13.ZodString;
+	atualizado_em: z13.ZodString;
+	ondas: z13.ZodArray<z13.ZodObject<{
+		data: z13.ZodString;
+		dados_ondas: z13.ZodArray<z13.ZodObject<{
+			hora: z13.ZodOptional<z13.ZodString>;
+			vento: z13.ZodNumber;
+			direcao_vento: z13.ZodString;
+			direcao_vento_desc: z13.ZodOptional<z13.ZodString>;
+			altura_onda: z13.ZodNumber;
+			direcao_onda: z13.ZodOptional<z13.ZodString>;
+			direcao_onda_desc: z13.ZodOptional<z13.ZodString>;
+			agitation: z13.ZodString;
+		}, "strip", z13.ZodTypeAny, {
+			hora?: string;
+			vento?: number;
+			direcao_vento?: string;
+			direcao_vento_desc?: string;
+			altura_onda?: number;
+			direcao_onda?: string;
+			direcao_onda_desc?: string;
+			agitation?: string;
+		}, {
+			hora?: string;
+			vento?: number;
+			direcao_vento?: string;
+			direcao_vento_desc?: string;
+			altura_onda?: number;
+			direcao_onda?: string;
+			direcao_onda_desc?: string;
+			agitation?: string;
+		}>, "many">;
+	}, "strip", z13.ZodTypeAny, {
+		data?: string;
+		dados_ondas?: {
+			hora?: string;
+			vento?: number;
+			direcao_vento?: string;
+			direcao_vento_desc?: string;
+			altura_onda?: number;
+			direcao_onda?: string;
+			direcao_onda_desc?: string;
+			agitation?: string;
+		}[];
+	}, {
+		data?: string;
+		dados_ondas?: {
+			hora?: string;
+			vento?: number;
+			direcao_vento?: string;
+			direcao_vento_desc?: string;
+			altura_onda?: number;
+			direcao_onda?: string;
+			direcao_onda_desc?: string;
+			agitation?: string;
+		}[];
+	}>, "many">;
+}, "strip", z13.ZodTypeAny, {
+	estado?: string;
+	cidade?: string;
+	atualizado_em?: string;
+	ondas?: {
+		data?: string;
+		dados_ondas?: {
+			hora?: string;
+			vento?: number;
+			direcao_vento?: string;
+			direcao_vento_desc?: string;
+			altura_onda?: number;
+			direcao_onda?: string;
+			direcao_onda_desc?: string;
+			agitation?: string;
+		}[];
+	}[];
+}, {
+	estado?: string;
+	cidade?: string;
+	atualizado_em?: string;
+	ondas?: {
+		data?: string;
+		dados_ondas?: {
+			hora?: string;
+			vento?: number;
+			direcao_vento?: string;
+			direcao_vento_desc?: string;
+			altura_onda?: number;
+			direcao_onda?: string;
+			direcao_onda_desc?: string;
+			agitation?: string;
+		}[];
+	}[];
+}>;
+/**
+* Type for ocean wave forecast
+*/
+type PrevisaoOndas = z13.infer<typeof PrevisaoOndasSchema>;
+/**
+* Get all cities available for weather forecast from CPTEC
+*
+* @returns Array of cities with ID, name, and state
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const cities = await getCidades();
+* console.log(cities);
+* // [
+* //   { id: 244, nome: "São Paulo", estado: "SP" },
+* //   { id: 201, nome: "Rio de Janeiro", estado: "RJ" },
+* //   ...
+* // ]
+* ```
+*/
+declare function getCidades(): Promise<Cidade[]>;
+/**
+* Get weather forecast for a specific city
+*
+* @param cityCode - CPTEC city code
+* @param days - Number of days for forecast (1-6, default: 1)
+* @returns Weather forecast with city info and climate data
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+* @throws {BrasilApiNotFoundError} If city not found
+*
+* @example
+* ```typescript
+* const forecast = await getPrevisao(244, 3);
+* console.log(forecast);
+* // {
+* //   cidade: "São Paulo",
+* //   estado: "SP",
+* //   atualizado_em: "2024-01-30 10:00:00",
+* //   clima: [
+* //     {
+* //       data: "2024-01-30",
+* //       condicao: "ps",
+* //       min: 18,
+* //       max: 28,
+* //       indice_uv: 8
+* //     },
+* //     ...
+* //   ]
+* // }
+* ```
+*/
+declare function getPrevisao(cityCode: number, days?: number): Promise<Previsao>;
+/**
+* Get ocean wave forecast for coastal cities
+*
+* @param cityCode - CPTEC city code (coastal city)
+* @returns Ocean wave forecast with wind, wave height, and agitation data
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+* @throws {BrasilApiNotFoundError} If city not found
+*
+* @example
+* ```typescript
+* const waves = await getPrevisaoOndas(241);
+* console.log(waves);
+* // {
+* //   cidade: "Santos",
+* //   estado: "SP",
+* //   atualizado_em: "2024-01-30 10:00:00",
+* //   ondas: [
+* //     {
+* //       data: "2024-01-30",
+* //       dados_ondas: [
+* //         {
+* //           vento: 15,
+* //           direcao_vento: "SE",
+* //           vento_medio: 12,
+* //           agitation: "Fraca",
+* //           altura_onda: 1.2
+* //         },
+* //         ...
+* //       ]
+* //     },
+* //     ...
+* //   ]
+* // }
+* ```
+*/
+declare function getPrevisaoOndas(cityCode: number): Promise<PrevisaoOndas>;
+import { z as z14 } from "zod";
+/**
+* Schema for currency information
+*/
+declare const MoedaSchema: z14.ZodObject<{
+	simbolo: z14.ZodString;
+	nome: z14.ZodString;
+	tipo_moeda: z14.ZodString;
+}, "strip", z14.ZodTypeAny, {
+	simbolo?: string;
+	nome?: string;
+	tipo_moeda?: string;
+}, {
+	simbolo?: string;
+	nome?: string;
+	tipo_moeda?: string;
+}>;
+/**
+* Type for currency
+*/
+type Moeda = z14.infer<typeof MoedaSchema>;
+/**
+* Schema for currency exchange rate response
+*/
+declare const CotacaoResponseSchema: z14.ZodObject<{
+	moeda: z14.ZodString;
+	data: z14.ZodString;
+	cotacoes: z14.ZodArray<z14.ZodObject<{
+		paridade_compra: z14.ZodNumber;
+		paridade_venda: z14.ZodNumber;
+		cotacao_compra: z14.ZodNumber;
+		cotacao_venda: z14.ZodNumber;
+		data_hora_cotacao: z14.ZodString;
+		tipo_boletim: z14.ZodString;
+	}, "strip", z14.ZodTypeAny, {
+		paridade_compra?: number;
+		paridade_venda?: number;
+		cotacao_compra?: number;
+		cotacao_venda?: number;
+		data_hora_cotacao?: string;
+		tipo_boletim?: string;
+	}, {
+		paridade_compra?: number;
+		paridade_venda?: number;
+		cotacao_compra?: number;
+		cotacao_venda?: number;
+		data_hora_cotacao?: string;
+		tipo_boletim?: string;
+	}>, "many">;
+}, "strip", z14.ZodTypeAny, {
+	moeda?: string;
+	data?: string;
+	cotacoes?: {
+		paridade_compra?: number;
+		paridade_venda?: number;
+		cotacao_compra?: number;
+		cotacao_venda?: number;
+		data_hora_cotacao?: string;
+		tipo_boletim?: string;
+	}[];
+}, {
+	moeda?: string;
+	data?: string;
+	cotacoes?: {
+		paridade_compra?: number;
+		paridade_venda?: number;
+		cotacao_compra?: number;
+		cotacao_venda?: number;
+		data_hora_cotacao?: string;
+		tipo_boletim?: string;
+	}[];
+}>;
+/**
+* Type for currency exchange rate response
+*/
+type Cotacao = z14.infer<typeof CotacaoResponseSchema>;
+/**
+* Get list of available currencies for exchange rate queries
+*
+* @returns Array of available currencies with symbol, name, and type
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const currencies = await getMoedas();
+* console.log(currencies);
+* // [
+* //   {
+* //     simbolo: "USD",
+* //     nome: "Dólar Americano",
+* //     tipo_moeda: "A"
+* //   },
+* //   {
+* //     simbolo: "EUR",
+* //     nome: "Euro",
+* //     tipo_moeda: "B"
+* //   },
+* //   ...
+* // ]
+* ```
+*/
+declare function getMoedas(): Promise<Moeda[]>;
+/**
+* Get exchange rate for a specific currency on a specific date
+*
+* @param moeda - Currency symbol (e.g., "USD", "EUR")
+* @param data - Date in format "MM-DD-YYYY"
+* @returns Exchange rate information with array of quotations
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+* @throws {BrasilApiNotFoundError} If rate not found for date
+*
+* @example
+* ```typescript
+* const rate = await getCotacao("USD", "01-30-2024");
+* console.log(rate);
+* // {
+* //   moeda: "USD",
+* //   data: "2024-01-30",
+* //   cotacoes: [
+* //     {
+* //       paridade_compra: 1,
+* //       paridade_venda: 1,
+* //       cotacao_compra: 4.95,
+* //       cotacao_venda: 4.96,
+* //       data_hora_cotacao: "2024-01-30 13:00:00",
+* //       tipo_boletim: "FECHAMENTO PTAX"
+* //     },
+* //     ...
+* //   ]
+* // }
+* ```
+*/
+declare function getCotacao(moeda: string, data: string): Promise<Cotacao>;
+import { z as z15 } from "zod";
+/**
+* Vehicle type for FIPE queries
+*/
+type TipoVeiculo = "carros" | "motos" | "caminhoes";
+/**
+* Schema for vehicle brand
+*/
+declare const FipeMarcaSchema: z15.ZodObject<{
+	nome: z15.ZodString;
+	valor: z15.ZodString;
+}, "strip", z15.ZodTypeAny, {
+	nome?: string;
+	valor?: string;
+}, {
+	nome?: string;
+	valor?: string;
+}>;
+/**
+* Type for vehicle brand
+*/
+type FipeMarca = z15.infer<typeof FipeMarcaSchema>;
+/**
+* Schema for vehicle price information
+*/
+declare const FipePrecoSchema: z15.ZodObject<{
+	valor: z15.ZodString;
+	marca: z15.ZodString;
+	modelo: z15.ZodString;
+	anoModelo: z15.ZodNumber;
+	combustivel: z15.ZodString;
+	codigoFipe: z15.ZodString;
+	mesReferencia: z15.ZodString;
+	tipoVeiculo: z15.ZodNumber;
+	siglaCombustivel: z15.ZodString;
+	dataConsulta: z15.ZodOptional<z15.ZodString>;
+}, "strip", z15.ZodTypeAny, {
+	valor?: string;
+	marca?: string;
+	modelo?: string;
+	anoModelo?: number;
+	combustivel?: string;
+	codigoFipe?: string;
+	mesReferencia?: string;
+	tipoVeiculo?: number;
+	siglaCombustivel?: string;
+	dataConsulta?: string;
+}, {
+	valor?: string;
+	marca?: string;
+	modelo?: string;
+	anoModelo?: number;
+	combustivel?: string;
+	codigoFipe?: string;
+	mesReferencia?: string;
+	tipoVeiculo?: number;
+	siglaCombustivel?: string;
+	dataConsulta?: string;
+}>;
+/**
+* Type for vehicle price information
+*/
+type FipePreco = z15.infer<typeof FipePrecoSchema>;
+/**
+* Schema for FIPE reference table
+*/
+declare const FipeTabelaSchema: z15.ZodObject<{
+	codigo: z15.ZodNumber;
+	mes: z15.ZodString;
+}, "strip", z15.ZodTypeAny, {
+	codigo?: number;
+	mes?: string;
+}, {
+	codigo?: number;
+	mes?: string;
+}>;
+/**
+* Type for FIPE reference table
+*/
+type FipeTabela = z15.infer<typeof FipeTabelaSchema>;
+/**
+* Get list of vehicle brands from FIPE
+*
+* @param tipoVeiculo - Type of vehicle ("carros", "motos", or
+* "caminhoes")
+* @returns Array of brands with name and value code
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const brands = await getFipeMarcas("carros");
+* console.log(brands);
+* // [
+* //   { nome: "Acura", valor: "1" },
+* //   { nome: "Audi", valor: "2" },
+* //   { nome: "BMW", valor: "3" },
+* //   ...
+* // ]
+* ```
+*/
+declare function getFipeMarcas(tipoVeiculo: TipoVeiculo): Promise<FipeMarca[]>;
+/**
+* Get vehicle price information by FIPE code
+*
+* @param codigoFipe - FIPE code (e.g., "004278-1")
+* @returns Vehicle price information including brand, model, year, fuel
+* type, and price
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+* @throws {BrasilApiNotFoundError} If vehicle not found
+*
+* @example
+* ```typescript
+* const price = await getFipePreco("004278-1");
+* console.log(price);
+* // {
+* //   valor: "R$ 45.000,00",
+* //   marca: "VW - VolksWagen",
+* //   modelo: "Gol 1.0",
+* //   anoModelo: 2020,
+* //   combustivel: "Gasolina",
+* //   codigoFipe: "004278-1",
+* //   mesReferencia: "janeiro de 2024",
+* //   tipoVeiculo: 1,
+* //   siglaCombustivel: "G"
+* // }
+* ```
+*/
+declare function getFipePreco(codigoFipe: string): Promise<FipePreco>;
+/**
+* Get FIPE reference tables
+*
+* @returns Array of reference tables with code and month description
+* @throws {BrasilApiNetworkError} On network errors
+* @throws {BrasilApiResponseError} On invalid response
+*
+* @example
+* ```typescript
+* const tables = await getFipeTabelas();
+* console.log(tables);
+* // [
+* //   { codigo: 290, mes: "janeiro de 2024" },
+* //   { codigo: 289, mes: "dezembro de 2023" },
+* //   { codigo: 288, mes: "novembro de 2023" },
+* //   ...
+* // ]
+* ```
+*/
+declare function getFipeTabelas(): Promise<FipeTabela[]>;
+declare const VERSION = "0.1.0";
+export { setConfig, resetConfig, getTaxas, getTaxa, getPrevisaoOndas, getPrevisao, getPixParticipants, getNcms, getNcm, getMunicipios, getMoedas, getIsbn, getFipeTabelas, getFipePreco, getFipeMarcas, getFeriados, getEstados, getDomainStatus, getDdd, getCotacao, getCorretoras, getCorretora, getConfig, getCnpj, getCidades, getCepV2, getCep, getBanks, getBank, configureBrasilApi, VERSION, TipoVeiculo, Taxa, PrevisaoOndas, Previsao, PixParticipant, Ncm, Municipio, Moeda, IsbnResponse, FipeTabela, FipePreco, FipeMarca, Feriado, Estado, DomainStatus, DddResponse, Cotacao, Corretora, CnpjResponse, Cidade, CepV2Response, CepResponse, BrasilApiValidationError, BrasilApiResponseError, BrasilApiNetworkError, BrasilApiError, BrasilApiConfig, Bank };