@wmmz/fn-api-client/dist/index.d.mts

Cliente HTTP para requisições API com tratamento de erros e respostas padronizadas

import { AxiosInstance, AxiosError } from 'axios';

/**
 * Interface para erro padronizado da API.
 * Representa um erro que ocorreu durante uma requisição,
 * contendo informações detalhadas sobre o problema.
 *
 * @example
 * ```typescript
 * const error: ApiError = {
 *   message: 'Usuário não encontrado',
 *   status: 404,
 *   code: 'USER_NOT_FOUND',
 *   details: {
 *     userId: '123',
 *     timestamp: '2024-03-20T10:00:00Z'
 *   }
 * }
 * ```
 */
interface ApiError {
    /** Mensagem descritiva do erro */
    message: string;
    /** Código de status HTTP do erro */
    status: number;
    /** Código interno do erro (opcional) */
    code?: string;
    /** Detalhes adicionais do erro (opcional) */
    details?: unknown;
}
/**
 * Interface base para respostas da API.
 * Padroniza o formato de resposta para todas as requisições bem-sucedidas.
 *
 * @example
 * ```typescript
 * interface User {
 *   id: number
 *   name: string
 *   email: string
 * }
 *
 * const response: ApiResponse<User> = {
 *   data: {
 *     id: 1,
 *     name: 'João Silva',
 *     email: 'joao@exemplo.com'
 *   },
 *   status: 200,
 *   message: 'Usuário encontrado com sucesso'
 * }
 * ```
 */
interface ApiResponse<T> {
    /** Dados retornados pela API */
    data: T;
    /** Código de status HTTP da resposta */
    status: number;
    /** Mensagem descritiva do resultado */
    message: string;
}
/**
 * Interface para callbacks de sucesso e erro.
 * Define as funções que serão chamadas após uma requisição,
 * permitindo tratamento personalizado dos resultados.
 *
 * @example
 * ```typescript
 * const callbacks: RequestCallbacks<User> = {
 *   onSuccess: (response) => {
 *     console.log('Usuário:', response.data)
 *     console.log('Status:', response.status)
 *     console.log('Mensagem:', response.message)
 *   },
 *   onError: (error) => {
 *     console.error('Erro:', error.message)
 *     console.error('Status:', error.status)
 *     if (error.code) {
 *       console.error('Código:', error.code)
 *     }
 *     if (error.details) {
 *       console.error('Detalhes:', error.details)
 *     }
 *   }
 * }
 * ```
 */
interface RequestCallbacks<T> {
    /** Função chamada quando a requisição é bem-sucedida */
    onSuccess?: (response: ApiResponse<T>) => void;
    /** Função chamada quando ocorre um erro na requisição */
    onError?: (error: ApiError) => void;
}
/**
 * Configurações do cliente API.
 * Define as opções de configuração para instanciar um cliente API.
 *
 * @example
 * ```typescript
 * const config: ApiClientConfig = {
 *   baseURL: 'https://api.exemplo.com',
 *   timeout: 5000,
 *   headers: {
 *     'Authorization': 'Bearer seu-token',
 *     'X-API-Version': '1.0',
 *     'Accept-Language': 'pt-BR'
 *   }
 * }
 * ```
 */
interface ApiClientConfig {
    /** URL base para todas as requisições */
    baseURL: string;
    /** Tempo limite em milissegundos (opcional, padrão: 10000) */
    timeout?: number;
    /** Headers customizados para todas as requisições (opcional) */
    headers?: Record<string, string>;
}
/**
 * Configuração de uma requisição HTTP.
 * Representa os dados que podem ser interceptados e modificados antes do envio.
 *
 * @example
 * ```typescript
 * const interceptor: RequestInterceptor = (config) => {
 *   const token = getToken()
 *   if (token) {
 *     config.headers = {
 *       ...config.headers,
 *       Authorization: `Bearer ${token}`
 *     }
 *   }
 *   return config
 * }
 * ```
 */
interface RequestConfig {
    /** URL da requisição */
    url?: string;
    /** Método HTTP */
    method?: string;
    /** Headers da requisição */
    headers?: Record<string, string>;
    /** Dados do corpo da requisição */
    data?: unknown;
    /** Parâmetros de query string */
    params?: Record<string, unknown>;
    /** Timeout específico para esta requisição */
    timeout?: number;
}
/**
 * Função interceptadora de requisições.
 * Permite modificar a configuração da requisição antes do envio.
 *
 * @param config Configuração da requisição
 * @returns Configuração modificada da requisição
 */
type RequestInterceptor = (config: RequestConfig) => RequestConfig;
/**
 * Função interceptadora de respostas.
 * Permite processar a resposta antes de retorná-la para o callback.
 *
 * @param response Resposta da requisição
 * @returns Resposta processada
 */
type ResponseInterceptor = <T>(response: ApiResponse<T>) => ApiResponse<T>;
/**
 * Função interceptadora de erros.
 * Permite processar erros antes de retorná-los para o callback.
 *
 * @param error Erro da requisição
 * @returns Erro processado ou uma nova resposta
 */
type ErrorInterceptor = (error: ApiError) => ApiError | Promise<ApiResponse<unknown>>;
/**
 * Parâmetros de query string para requisições GET e DELETE.
 * Permite enviar parâmetros na URL da requisição.
 *
 * @example
 * ```typescript
 * const params: QueryParams = {
 *   userId: '123',
 *   agendaId: '456',
 *   includeDetails: true,
 *   limit: 10
 * }
 *
 * // Será convertido para: ?userId=123&agendaId=456&includeDetails=true&limit=10
 * ```
 */
interface QueryParams {
    [key: string]: string | number | boolean | undefined;
}

/**
 * Interface para configuração do cliente GraphQL.
 * Define as opções de configuração específicas para o cliente GraphQL do Cube.
 *
 * @example
 * ```typescript
 * const config: CubeGraphQLConfig = {
 *   baseURL: 'http://localhost:4000/cubejs-api/graphql',
 *   timeout: 30000,
 *   headers: {
 *     'Authorization': 'Bearer seu-token',
 *     'X-Cube-Version': '2.0'
 *   }
 * }
 * ```
 */
interface CubeGraphQLConfig {
    /** URL base do endpoint GraphQL */
    baseURL: string;
    /** Tempo limite em milissegundos (opcional, padrão: 30000) */
    timeout?: number;
    /** Headers customizados para todas as requisições (opcional) */
    headers?: Record<string, string>;
}
/**
 * Interface para definir os campos que podem ser selecionados na query.
 * Permite especificar quais campos devem ser retornados para cada entidade.
 *
 * @example
 * ```typescript
 * const fields: CubeQueryFields = {
 *   vendas: {
 *     total: true,
 *     data: true,
 *     status: true
 *   },
 *   cliente: {
 *     nome: true,
 *     email: true,
 *     tipo: true
 *   }
 * }
 * ```
 */
interface CubeQueryFields {
    /**
     * Mapa de entidades e seus campos.
     * A chave é o nome da entidade e o valor é um objeto com os campos a serem selecionados.
     */
    [entity: string]: {
        /**
         * Mapa de campos da entidade.
         * A chave é o nome do campo e o valor indica se ele deve ser incluído.
         */
        [field: string]: boolean | undefined;
    } | undefined;
}
/**
 * Interface para definir os filtros que podem ser aplicados na query.
 * Suporta diversos operadores de comparação para filtrar os dados.
 *
 * @example
 * ```typescript
 * const filtroVenda: CubeQueryFilter = {
 *   equals: 1000,
 *   greaterThan: 500,
 *   in: [1, 2, 3],
 *   contains: 'APROVADA'
 * }
 *
 * const filtroData: CubeQueryFilter = {
 *   between: ['2024-01-01', '2024-12-31'],
 *   notEquals: '2024-03-15'
 * }
 * ```
 */
interface CubeQueryFilter {
    /** Filtro de igualdade exata */
    equals?: number | string;
    /** Filtro de diferença */
    notEquals?: number | string;
    /** Filtro de inclusão em lista de valores */
    in?: (number | string)[];
    /** Filtro de exclusão de lista de valores */
    notIn?: (number | string)[];
    /** Filtro de texto contendo valor */
    contains?: string;
    /** Filtro de texto não contendo valor */
    notContains?: string;
    /**
     * Permite extensão com operadores adicionais.
     * Exemplos: greaterThan, lessThan, between, etc.
     */
    [key: string]: number | string | (number | string)[] | undefined;
}
/**
 * Interface para definir a estrutura dos filtros por entidade.
 * Permite agrupar filtros por entidade e campo.
 *
 * @example
 * ```typescript
 * const where: CubeQueryWhere = {
 *   vendas: {
 *     total: { greaterThan: 1000 },
 *     data: { between: ['2024-01-01', '2024-12-31'] },
 *     status: { in: ['APROVADA', 'CONCLUIDA'] }
 *   },
 *   cliente: {
 *     tipo: { equals: 'PJ' },
 *     regiao: { in: ['SUDESTE', 'SUL'] }
 *   }
 * }
 * ```
 */
interface CubeQueryWhere {
    /**
     * Mapa de entidades e seus filtros.
     * A chave é o nome da entidade e o valor é um objeto com os filtros por campo.
     */
    [entity: string]: {
        /**
         * Mapa de campos e seus filtros.
         * A chave é o nome do campo e o valor é o objeto de filtro.
         */
        [field: string]: CubeQueryFilter | undefined;
    } | undefined;
}
/**
 * Interface para consulta CubeQuery.
 * Define todas as opções disponíveis para construir uma consulta no Cube.
 *
 * @example
 * ```typescript
 * const options: CubeQueryOptions = {
 *   limit: 20,
 *   offset: 0,
 *   where: {
 *     vendas: {
 *       total: { greaterThan: 1000 },
 *       status: { in: ['APROVADA', 'CONCLUIDA'] }
 *     }
 *   },
 *   fields: {
 *     vendas: {
 *       id: true,
 *       total: true,
 *       status: true
 *     }
 *   },
 *   defaultEntity: 'vendas',
 *   defaultFields: ['id', 'total', 'status']
 * }
 * ```
 */
interface CubeQueryOptions {
    /** Limite de registros por página */
    limit?: number;
    /** Número de registros para pular (paginação) */
    offset?: number;
    /** Filtros a serem aplicados na consulta */
    where?: CubeQueryWhere;
    /** Campos a serem retornados na consulta */
    fields?: CubeQueryFields;
    /** Entidade padrão para consulta quando não especificada */
    defaultEntity?: string;
    /** Campos padrão a serem retornados quando não especificados */
    defaultFields?: string[];
}

/**
 * Constrói uma string de campos para a query GraphQL.
 * Transforma um objeto de campos selecionados em uma string formatada
 * para ser usada em uma query GraphQL do Cube.
 *
 * @param fields Objeto com os campos a serem selecionados
 * @returns String formatada com os campos no formato GraphQL
 *
 * @example
 * ```typescript
 * const fields = {
 *   vendas: {
 *     total: true,
 *     data: true,
 *     status: true
 *   },
 *   cliente: {
 *     nome: true,
 *     email: true
 *   }
 * }
 *
 * const result = buildFields(fields)
 * // Resultado:
 * //     vendas {
 * //       total
 * //       data
 * //       status
 * //     }
 * //     cliente {
 * //       nome
 * //       email
 * //     }
 * ```
 */
declare function buildFields(fields?: CubeQueryFields): string;
/**
 * Constrói uma string de filtros para a query GraphQL.
 * Transforma um objeto de filtros em uma string formatada
 * para ser usada como cláusula WHERE em uma query GraphQL do Cube.
 *
 * @param where Objeto com os filtros a serem aplicados
 * @returns String formatada com os filtros no formato GraphQL
 *
 * @example
 * ```typescript
 * const where = {
 *   vendas: {
 *     total: { greaterThan: 1000, lessThan: 5000 },
 *     status: { in: ['APROVADA', 'CONCLUIDA'] }
 *   },
 *   cliente: {
 *     tipo: { equals: 'PJ' }
 *   }
 * }
 *
 * const result = buildWhereClause(where)
 * // Resultado:
 * // where: {
 * //   vendas: {
 * //     total: { greaterThan: 1000, lessThan: 5000 },
 * //     status: { in: ["APROVADA", "CONCLUIDA"] }
 * //   },
 * //   cliente: {
 * //     tipo: { equals: "PJ" }
 * //   }
 * // }
 * ```
 */
declare function buildWhereClause(where?: CubeQueryWhere): string;
/**
 * Constrói uma query GraphQL completa para o Cube.
 * Combina todas as opções fornecidas (campos, filtros, paginação)
 * em uma única string de query GraphQL formatada.
 *
 * @param options Opções da query
 * @param options.limit Limite de registros por página
 * @param options.offset Número de registros para pular (paginação)
 * @param options.where Filtros a serem aplicados
 * @param options.fields Campos a serem retornados
 * @param options.defaultEntity Entidade padrão para consulta
 * @param options.defaultFields Campos padrão a serem retornados
 * @returns String da query GraphQL formatada
 *
 * @example
 * ```typescript
 * const query = buildCubeQuery({
 *   limit: 20,
 *   offset: 0,
 *   where: {
 *     vendas: {
 *       total: { greaterThan: 1000 },
 *       status: { in: ['APROVADA', 'CONCLUIDA'] }
 *     }
 *   },
 *   fields: {
 *     vendas: {
 *       id: true,
 *       total: true,
 *       status: true
 *     }
 *   },
 *   defaultEntity: 'vendas',
 *   defaultFields: ['id', 'total', 'status']
 * })
 *
 * // Resultado:
 * // query CubeQuery {
 * //   cube(
 * //     limit: 20
 * //     offset: 0
 * //     where: {
 * //       vendas: {
 * //         total: { greaterThan: 1000 },
 * //         status: { in: ["APROVADA", "CONCLUIDA"] }
 * //       }
 * //     }
 * //   ) {
 * //     vendas {
 * //       id
 * //       total
 * //       status
 * //     }
 * //   }
 * // }
 * ```
 */
declare function buildCubeQuery(options?: CubeQueryOptions): string;

/**
 * Interface para configuração do cliente GraphQL
 */
interface GraphQLConfig {
    baseURL: string;
    timeout?: number;
    headers?: Record<string, string>;
}
/**
 * Interface para variáveis da query GraphQL
 */
interface GraphQLVariables {
    [key: string]: unknown;
}
/**
 * Cliente base para realizar consultas GraphQL.
 * Fornece uma interface simplificada para executar queries e mutations GraphQL
 * com tratamento automático de erros e padronização de respostas.
 *
 * Características principais:
 * - Suporte a queries e mutations
 * - Tratamento automático de erros
 * - Respostas padronizadas
 * - Tipagem forte com TypeScript
 * - Suporte a variáveis dinâmicas
 *
 * @example
 * ```typescript
 * // Configuração do cliente
 * const client = new GraphQLClient({
 *   baseURL: 'https://api.exemplo.com/graphql',
 *   headers: {
 *     'Authorization': 'Bearer seu-token'
 *   }
 * })
 *
 * // Exemplo de query com variáveis
 * const query = `
 *   query GetUser($id: ID!) {
 *     user(id: $id) {
 *       id
 *       name
 *       email
 *       posts {
 *         id
 *         title
 *       }
 *     }
 *   }
 * `
 *
 * await client.query(query, { id: '123' }, {
 *   onSuccess: (response) => {
 *     const user = response.data.user
 *     console.log('Usuário:', user.name)
 *     console.log('Posts:', user.posts.length)
 *   },
 *   onError: (error) => console.error('Erro:', error.message)
 * })
 *
 * // Exemplo de mutation
 * const mutation = `
 *   mutation CreateUser($input: UserInput!) {
 *     createUser(input: $input) {
 *       id
 *       name
 *       email
 *     }
 *   }
 * `
 *
 * const variables = {
 *   input: {
 *     name: 'João Silva',
 *     email: 'joao@exemplo.com',
 *     password: 'senha123'
 *   }
 * }
 *
 * await client.mutate(mutation, variables, {
 *   onSuccess: (response) => console.log('Usuário criado:', response.data.createUser),
 *   onError: (error) => console.error('Erro ao criar usuário:', error.message)
 * })
 * ```
 */
declare class GraphQLClient {
    protected api: AxiosInstance;
    /**
     * Cria uma nova instância do cliente GraphQL
     * @param config Configurações do cliente
     * @param config.baseURL URL do endpoint GraphQL
     * @param config.timeout Tempo limite em milissegundos (padrão: 30000)
     * @param config.headers Headers customizados para todas as requisições
     */
    constructor(config: GraphQLConfig);
    /**
     * Extrai e padroniza os dados de erro do Axios
     * @param error Erro original do Axios
     * @returns Objeto de erro padronizado com mensagem, status e detalhes
     * @internal
     */
    protected extractErrorData(error: AxiosError): ApiError;
    /**
     * Extrai e padroniza os dados da resposta do Axios
     * @param response Resposta original do Axios
     * @returns Objeto de resposta padronizado com dados, status e mensagem
     * @internal
     */
    protected extractResponseData<T>(response: any): ApiResponse<T>;
    /**
     * Executa uma query GraphQL
     * @param query String da query GraphQL
     * @param variables Variáveis a serem passadas para a query
     * @param callbacks Objeto com callbacks de sucesso e erro
     * @param callbacks.onSuccess Callback chamado quando a query é bem sucedida
     * @param callbacks.onError Callback chamado quando ocorre um erro
     *
     * @example
     * ```typescript
     * const query = `
     *   query GetProducts($category: String!, $limit: Int) {
     *     products(category: $category, limit: $limit) {
     *       id
     *       name
     *       price
     *     }
     *   }
     * `
     *
     * const variables = {
     *   category: 'electronics',
     *   limit: 10
     * }
     *
     * await client.query(query, variables, {
     *   onSuccess: (response) => console.log('Produtos:', response.data.products),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     * ```
     */
    query<T>(query: string, variables?: GraphQLVariables, { onSuccess, onError }?: RequestCallbacks<T>): Promise<void>;
    /**
     * Executa uma mutation GraphQL
     * @param mutation String da mutation GraphQL
     * @param variables Variáveis a serem passadas para a mutation
     * @param callbacks Objeto com callbacks de sucesso e erro
     * @param callbacks.onSuccess Callback chamado quando a mutation é bem sucedida
     * @param callbacks.onError Callback chamado quando ocorre um erro
     *
     * @example
     * ```typescript
     * const mutation = `
     *   mutation UpdateProduct($id: ID!, $input: ProductInput!) {
     *     updateProduct(id: $id, input: $input) {
     *       id
     *       name
     *       price
     *     }
     *   }
     * `
     *
     * const variables = {
     *   id: '123',
     *   input: {
     *     name: 'Novo Nome',
     *     price: 99.99
     *   }
     * }
     *
     * await client.mutate(mutation, variables, {
     *   onSuccess: (response) => console.log('Produto atualizado:', response.data.updateProduct),
     *   onError: (error) => console.error('Erro ao atualizar:', error.message)
     * })
     * ```
     */
    mutate<T>(mutation: string, variables?: GraphQLVariables, { onSuccess, onError }?: RequestCallbacks<T>): Promise<void>;
}

/**
 * Cliente específico para realizar consultas GraphQL no Cube.
 * Estende o GraphQLClient base adicionando funcionalidades específicas para
 * consultas no Cube, como construção automática de queries e tratamento
 * especializado de respostas.
 *
 * Características principais:
 * - Construção automática de queries Cube
 * - Suporte a filtros complexos
 * - Paginação integrada
 * - Seleção de campos dinâmica
 * - Tratamento especializado de respostas Cube
 *
 * @example
 * ```typescript
 * // Configuração do cliente
 * const client = new CubeGraphQLClient({
 *   baseURL: 'http://localhost:4000',
 *   timeout: 30000,
 *   headers: {
 *     'Authorization': 'Bearer seu-token'
 *   }
 * })
 *
 * // Exemplo de consulta simples
 * await client.query('/cubejs-api/graphql', {
 *   limit: 10,
 *   fields: {
 *     vendas: {
 *       total: true,
 *       data: true,
 *       cliente: true
 *     }
 *   }
 * }, {
 *   onSuccess: (response) => console.log('Vendas:', response.data),
 *   onError: (error) => console.error('Erro:', error.message)
 * })
 *
 * // Exemplo de consulta com filtros complexos
 * await client.query('/cubejs-api/graphql', {
 *   limit: 20,
 *   offset: 0,
 *   where: {
 *     vendas: {
 *       total: { greaterThan: 1000 },
 *       data: { between: ['2024-01-01', '2024-12-31'] },
 *       status: { in: ['APROVADA', 'CONCLUIDA'] }
 *     },
 *     cliente: {
 *       tipo: { equals: 'PJ' },
 *       regiao: { in: ['SUDESTE', 'SUL'] }
 *     }
 *   },
 *   fields: {
 *     vendas: {
 *       id: true,
 *       total: true,
 *       data: true,
 *       status: true
 *     },
 *     cliente: {
 *       nome: true,
 *       tipo: true,
 *       regiao: true
 *     }
 *   },
 *   defaultEntity: 'vendas',
 *   defaultFields: ['id', 'total', 'data', 'status']
 * }, {
 *   onSuccess: (response) => {
 *     console.log('Total de registros:', response.data.length)
 *     console.log('Dados:', response.data)
 *   },
 *   onError: (error) => {
 *     console.error('Erro na consulta:', error.message)
 *     console.error('Detalhes:', error.details)
 *   }
 * })
 * ```
 */
declare class CubeGraphQLClient extends GraphQLClient {
    /**
     * Realiza uma consulta GraphQL específica para o Cube
     * @param url Endpoint da API GraphQL do Cube
     * @param options Opções da query do Cube
     * @param options.limit Limite de registros por página
     * @param options.offset Número de registros para pular (paginação)
     * @param options.where Filtros a serem aplicados na consulta
     * @param options.fields Campos a serem retornados na consulta
     * @param options.defaultEntity Entidade padrão para consulta
     * @param options.defaultFields Campos padrão a serem retornados
     * @param callbacks Callbacks para sucesso e erro
     *
     * @example
     * ```typescript
     * // Exemplo de consulta com agregações
     * await client.query('/cubejs-api/graphql', {
     *   where: {
     *     vendas: {
     *       data: { equals: '2024-03-01' }
     *     }
     *   },
     *   fields: {
     *     vendas: {
     *       total_vendas: true,
     *       quantidade_pedidos: true,
     *       ticket_medio: true
     *     }
     *   }
     * }, {
     *   onSuccess: (response) => console.log('Métricas:', response.data),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     * ```
     */
    query<T>(url: string, options?: CubeQueryOptions, callbacks?: RequestCallbacks<T>): Promise<void>;
    /**
     * Extrai dados da resposta do Axios e padroniza o formato específico do Cube
     * @param response Resposta original do Axios
     * @returns Objeto de resposta padronizado com dados do Cube
     * @internal
     */
    protected extractResponseData<T>(response: any): ApiResponse<T>;
}

/**
 * Cliente HTTP para requisições API com tratamento de erros e respostas padronizadas.
 * Fornece uma interface simplificada para realizar requisições HTTP com tratamento automático
 * de erros e padronização de respostas, incluindo suporte a interceptadores.
 *
 * @example
 * ```typescript
 * // Criando uma instância do cliente
 * const api = new ApiClient({
 *   baseURL: 'https://api.exemplo.com',
 *   timeout: 5000,
 *   headers: {
 *     'Authorization': 'Bearer seu-token'
 *   }
 * })
 *
 * // Adicionando interceptador de requisição para token dinâmico
 * api.addRequestInterceptor((config) => {
 *   const token = getToken()
 *   if (token) {
 *     config.headers = {
 *       ...config.headers,
 *       Authorization: `Bearer ${token}`
 *     }
 *   }
 *   return config
 * })
 *
 * // Exemplo de GET com callbacks
 * api.get('/usuarios', {
 *   onSuccess: (response) => {
 *     console.log('Dados:', response.data)
 *     console.log('Status:', response.status)
 *     console.log('Mensagem:', response.message)
 *   },
 *   onError: (error) => {
 *     console.error('Erro:', error.message)
 *     console.error('Status:', error.status)
 *     console.error('Detalhes:', error.details)
 *   }
 * })
 *
 * // Exemplo de POST com dados
 * const novoUsuario = {
 *   nome: 'João Silva',
 *   email: 'joao@exemplo.com'
 * }
 *
 * api.post('/usuarios', novoUsuario, {
 *   onSuccess: (response) => console.log('Usuário criado:', response.data),
 *   onError: (error) => console.error('Erro ao criar usuário:', error.message)
 * })
 * ```
 */
declare class ApiClient {
    private api;
    private requestInterceptors;
    private responseInterceptors;
    private errorInterceptors;
    /**
     * Cria uma nova instância do cliente API
     * @param config Configurações do cliente
     * @param config.baseURL URL base para todas as requisições
     * @param config.timeout Tempo limite em milissegundos (padrão: 10000)
     * @param config.headers Headers customizados para todas as requisições
     */
    constructor(config: ApiClientConfig);
    /**
     * Adiciona um interceptador de requisição.
     * Permite modificar a configuração da requisição antes do envio.
     *
     * @param interceptor Função que recebe e retorna a configuração da requisição
     *
     * @example
     * ```typescript
     * api.addRequestInterceptor((config) => {
     *   const token = storage.getToken()
     *   if (token) {
     *     config.headers = {
     *       ...config.headers,
     *       Authorization: `Bearer ${token}`
     *     }
     *   }
     *   return config
     * })
     * ```
     */
    addRequestInterceptor(interceptor: RequestInterceptor): void;
    /**
     * Adiciona um interceptador de resposta.
     * Permite processar a resposta antes de retorná-la para o callback.
     *
     * @param interceptor Função que recebe e retorna a resposta processada
     *
     * @example
     * ```typescript
     * api.addResponseInterceptor((response) => {
     *   console.log('Resposta interceptada:', response.status)
     *   return {
     *     ...response,
     *     message: `[${new Date().toISOString()}] ${response.message}`
     *   }
     * })
     * ```
     */
    addResponseInterceptor(interceptor: ResponseInterceptor): void;
    /**
     * Adiciona um interceptador de erro.
     * Permite processar erros antes de retorná-los para o callback.
     *
     * @param interceptor Função que recebe um erro e retorna erro processado ou nova resposta
     *
     * @example
     * ```typescript
     * api.addErrorInterceptor(async (error) => {
     *   if (error.status === 401) {
     *     await refreshToken()
     *     // Pode retornar um novo ApiResponse ou o erro processado
     *     return {
     *       ...error,
     *       message: 'Token renovado automaticamente'
     *     }
     *   }
     *   return error
     * })
     * ```
     */
    addErrorInterceptor(interceptor: ErrorInterceptor): void;
    /**
     * Remove um interceptador de requisição específico.
     * @param interceptor Interceptador a ser removido
     */
    removeRequestInterceptor(interceptor: RequestInterceptor): void;
    /**
     * Remove um interceptador de resposta específico.
     * @param interceptor Interceptador a ser removido
     */
    removeResponseInterceptor(interceptor: ResponseInterceptor): void;
    /**
     * Remove um interceptador de erro específico.
     * @param interceptor Interceptador a ser removido
     */
    removeErrorInterceptor(interceptor: ErrorInterceptor): void;
    /**
     * Remove todos os interceptadores.
     */
    clearInterceptors(): void;
    /**
     * Aplica todos os interceptadores de requisição à configuração.
     * @param config Configuração inicial da requisição
     * @returns Configuração processada pelos interceptadores
     * @internal
     */
    private applyRequestInterceptors;
    /**
     * Aplica todos os interceptadores de resposta.
     * @param response Resposta original
     * @returns Resposta processada pelos interceptadores
     * @internal
     */
    private applyResponseInterceptors;
    /**
     * Aplica todos os interceptadores de erro.
     * @param error Erro original
     * @returns Erro processado ou nova resposta
     * @internal
     */
    private applyErrorInterceptors;
    /**
     * Extrai e padroniza os dados de erro do Axios
     * @param error Erro original do Axios
     * @returns Objeto de erro padronizado
     * @internal
     */
    private extractErrorData;
    /**
     * Extrai e padroniza os dados da resposta do Axios
     * @param response Resposta original do Axios
     * @returns Objeto de resposta padronizado
     * @internal
     */
    private extractResponseData;
    /**
     * Realiza uma requisição GET
     * @param url Caminho da requisição (será concatenado com baseURL)
     * @param paramsOrCallbacks Parâmetros de query string ou objeto com callbacks
     * @param callbacks Objeto com callbacks de sucesso e erro (opcional se parâmetros forem fornecidos)
     *
     * @example
     * ```typescript
     * // GET simples
     * api.get('/usuarios/1', {
     *   onSuccess: (response) => console.log('Usuário:', response.data),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     *
     * // GET com parâmetros
     * api.get('/votos', { userId: '123', agendaId: '456' }, {
     *   onSuccess: (response) => console.log('Voto:', response.data),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     * ```
     */
    get<T>(url: string, paramsOrCallbacks?: QueryParams | RequestCallbacks<T>, callbacks?: RequestCallbacks<T>): Promise<void>;
    /**
     * Realiza uma requisição POST
     * @param url Caminho da requisição (será concatenado com baseURL)
     * @param data Dados a serem enviados no corpo da requisição
     * @param callbacks Objeto com callbacks de sucesso e erro
     * @param callbacks.onSuccess Callback chamado em caso de sucesso
     * @param callbacks.onError Callback chamado em caso de erro
     *
     * @example
     * ```typescript
     * const dados = { nome: 'João', idade: 30 }
     * api.post('/usuarios', dados, {
     *   onSuccess: (response) => console.log('Criado:', response.data),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     * ```
     */
    post<T>(url: string, data: unknown, { onSuccess, onError }?: RequestCallbacks<T>): Promise<void>;
    /**
     * Realiza uma requisição PUT
     * @param url Caminho da requisição (será concatenado com baseURL)
     * @param data Dados a serem enviados no corpo da requisição
     * @param callbacks Objeto com callbacks de sucesso e erro
     * @param callbacks.onSuccess Callback chamado em caso de sucesso
     * @param callbacks.onError Callback chamado em caso de erro
     *
     * @example
     * ```typescript
     * const atualizacao = { idade: 31 }
     * api.put('/usuarios/1', atualizacao, {
     *   onSuccess: (response) => console.log('Atualizado:', response.data),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     * ```
     */
    put<T>(url: string, data: unknown, { onSuccess, onError }?: RequestCallbacks<T>): Promise<void>;
    /**
     * Realiza uma requisição DELETE
     * @param url Caminho da requisição (será concatenado com baseURL)
     * @param paramsOrCallbacks Parâmetros de query string ou objeto com callbacks
     * @param callbacks Objeto com callbacks de sucesso e erro (opcional se parâmetros forem fornecidos)
     *
     * @example
     * ```typescript
     * // DELETE simples
     * api.delete('/usuarios/1', {
     *   onSuccess: (response) => console.log('Deletado com sucesso'),
     *   onError: (error) => console.error('Erro ao deletar:', error.message)
     * })
     *
     * // DELETE com parâmetros
     * api.delete('/votos', { userId: '123', agendaId: '456' }, {
     *   onSuccess: (response) => console.log('Voto removido:', response.data),
     *   onError: (error) => console.error('Erro:', error.message)
     * })
     * ```
     */
    delete<T>(url: string, paramsOrCallbacks?: QueryParams | RequestCallbacks<T>, callbacks?: RequestCallbacks<T>): Promise<void>;
}

export { ApiClient, type ApiClientConfig, type ApiError, type ApiResponse, CubeGraphQLClient, type CubeGraphQLConfig, type CubeQueryFields, type CubeQueryFilter, type CubeQueryOptions, type CubeQueryWhere, type ErrorInterceptor, type QueryParams, type RequestCallbacks, type RequestConfig, type RequestInterceptor, type ResponseInterceptor, buildCubeQuery, buildFields, buildWhereClause };