import z from 'zod';
import _dayjs from 'dayjs';
export { Dayjs, ManipulateType } from 'dayjs';
import _duration from 'dayjs/plugin/duration';
import _isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
import _isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
import _minMax from 'dayjs/plugin/minMax';
import _relativeTime from 'dayjs/plugin/relativeTime';
import _timezone from 'dayjs/plugin/timezone';
import _utc from 'dayjs/plugin/utc';
import _weekOfYear from 'dayjs/plugin/weekOfYear';
import { v4 } from 'uuid';

declare const aleatorio: (tamanho?: number) => string;

type TipoPayloadAuditoria = {
    /** UUID do registro de auditoria */
    codigo?: string | null;
    /** UUID do usuario da acao (pode ser null se for processo do sistema que não registrou) */
    usuario_criacao: string | null;
    /** Timestamp ou data de criacao / execucao */
    data_criacao: string | Date;
    /** Nome exato da tabela no banco que originou o registro */
    tabela_origem: string;
    /** Código único (UUID) do registro na tabela original */
    codigo_origem: string;
    /** JSON contendo o snapshot das colunas novas / editadas */
    novo: Record<string, any>;
    /** JSON contendo o snapshot das colunas antes da edição */
    anterior: Record<string, any>;
    /** Hash ou controle de versao do item, usualmente preenchido por new.ver_seg */
    __versao: string;
    /** Tipo de operação que gerou a auditoria */
    acao: "criar" | "atualizar" | "deletar" | string;
    /** Versão do sistema no momento em que a ação ocorreu */
    versao_sistema: string;
};

/** gerar uma função de cache para uso em memoria  */
declare const cacheM: <T>(chave: any, valor?: T, validadeSeg?: number) => T | undefined;
declare const verCacheM: () => {
    [k: string]: {
        /** new Date().getTime() */
        validade?: number | undefined;
        valor: any;
    } | undefined;
};
declare const cacheMemoria: <T>(chave: any, valor?: T, validadeSeg?: number) => T | undefined;
/** para uso fixo dentro de uma função, trava a chave */
declare const cacheMFixo: (chave: any) => <T>(valor?: T) => T | undefined;

declare const uuid_null = "00000000-0000-0000-0000-000000000000";
/** Colunas Presentes n maioria das tabelas */
declare enum camposComuns {
    codigo = "codigo",
    excluido = "excluido",
    data_hora_criacao = "data_hora_criacao",
    data_hora_atualizacao = "data_hora_atualizacao",
    codigo_usuario_criacao = "codigo_usuario_criacao",
    codigo_usuario_atualizacao = "codigo_usuario_atualizacao",
    versao = "versao"
}
/** Palavras comumente usadas */
declare enum tx {
    token = "token"
}
declare enum tipoUsuarioResiduos {
    Usuario = "usuario",
    Fornecedor = "fornecedor"
}

declare enum operadores {
    "=" = "=",
    "!=" = "!=",
    ">" = ">",
    ">=" = ">=",
    "<" = "<",
    "<=" = "<=",
    like = "like",
    in = "in",
    isNull = "isNull"
}
type tipoFiltro = {
    coluna: string;
    valor: any;
    operador: keyof typeof operadores | operadores;
    ou?: boolean;
};
type interfaceConsulta = {
    offset?: number;
    limit?: number;
    filtros?: tipoFiltro[];
    ordem?: string;
    ordemTipo?: "asc" | "desc";
    colunas?: string[];
    apenasConsulta?: boolean;
    apenasContagem?: boolean;
};
declare const zOperadores: z.ZodEnum<{
    "=": "=";
    "!=": "!=";
    ">": ">";
    ">=": ">=";
    "<": "<";
    "<=": "<=";
    like: "like";
    in: "in";
    isNull: "isNull";
}>;
declare const zFiltro: z.ZodObject<{
    coluna: z.ZodString;
    valor: z.ZodAny;
    operador: z.ZodEnum<{
        "=": "=";
        "!=": "!=";
        ">": ">";
        ">=": ">=";
        "<": "<";
        "<=": "<=";
        like: "like";
        in: "in";
        isNull: "isNull";
    }>;
    ou: z.ZodOptional<z.ZodBoolean>;
}, z.core.$strip>;

/**
 * Utilitário de configuração do Dayjs focado em compatibilidade com SSR.
 *
 * PROBLEMA:
 * A importação direta do `dayjs` e seus plugins frequentemente causa conflitos em ambientes
 * de Renderização do Lado do Servidor (SSR), como Nuxt ou Next.js, devido a discrepâncias
 * na resolução de módulos (ESM vs CJS) e instabilidades de importação.
 *
 * SOLUÇÃO:
 * Este módulo utiliza o padrão de Injeção de Dependência. Ele expõe apenas tipagens e
 * uma função de configuração (`defineDayjsBr`). A responsabilidade de importar as
 * bibliotecas "vivas" é delegada à aplicação consumidora (o cliente da função).
 *
 * Isso permite que o bundler da aplicação principal (Vite, Webpack, etc.) gerencie as
 * instâncias, garantindo consistência e evitando erros de "module not found" ou
 * instâncias duplicadas/não inicializadas adequadamente.
 */

/**
 * Inicializa e configura o Dayjs com o locale 'pt-br' e plugins essenciais.
 *
 * MODO DE USO:
 * Importe os pacotes reais na sua aplicação e passe-os para esta função.
 *
 * @example
 * ```ts
 * // Em seu arquivo de configuração (ex: plugins/dayjs.ts):
 *       import dayjs from "dayjs"
 *       import duration from "dayjs/plugin/duration"
 *       import isSameOrAfter from "dayjs/plugin/isSameOrAfter"
 *       import isSameOrBefore from "dayjs/plugin/isSameOrBefore"
 *       import minMax from "dayjs/plugin/minMax"
 *       import relativeTime from "dayjs/plugin/relativeTime"
 *       import timezone from "dayjs/plugin/timezone"
 *       import utc from "dayjs/plugin/utc"
 *       import weekOfYear from "dayjs/plugin/weekOfYear"
 *       import { iniciarDayjsBr } from "p-comuns"
 *       import "dayjs/locale/pt-br" // Importante: importar o locale!

 *       export const dayjsbr = iniciarDayjsBr({
 *       dayjs,
 *       duration,
 *       isSameOrAfter,
 *       isSameOrBefore,
 *       minMax,
 *       relativeTime,
 *       timezone,
 *       utc,
 *       weekOfYear,
 *       })
 * ```
 */
declare const iniciarDayjsBr: ({ dayjs, duration, isSameOrAfter, isSameOrBefore, minMax, relativeTime, timezone, utc, weekOfYear, }: {
    dayjs: typeof _dayjs;
    duration: typeof _duration;
    isSameOrAfter: typeof _isSameOrAfter;
    isSameOrBefore: typeof _isSameOrBefore;
    minMax: typeof _minMax;
    relativeTime: typeof _relativeTime;
    timezone: typeof _timezone;
    utc: typeof _utc;
    weekOfYear: typeof _weekOfYear;
}) => typeof _dayjs;
/**
 * @deprecated Use iniciarDayjsBr em vez de definirDayjsBr. O método defineDayjsBr está obsoleto e será removido em futuras versões.
 */
declare const defineDayjsBr: ({ dayjs, duration, isSameOrAfter, isSameOrBefore, minMax, relativeTime, timezone, utc, weekOfYear, }: {
    dayjs: typeof _dayjs;
    duration: typeof _duration;
    isSameOrAfter: typeof _isSameOrAfter;
    isSameOrBefore: typeof _isSameOrBefore;
    minMax: typeof _minMax;
    relativeTime: typeof _relativeTime;
    timezone: typeof _timezone;
    utc: typeof _utc;
    weekOfYear: typeof _weekOfYear;
}) => typeof _dayjs;

declare const link_paiol = "https://paiol.idz.one";

type tiposArquivo = "imagem" | "documento" | "vídeo" | "outros";
declare const extensoes: {
    ext: string;
    tipo: tiposArquivo;
    mime: string;
}[];
/**
 *  Função que retorna o tipo do arquivo
 * @param nomeArquivo
 * @returns
 */
declare const tipoArquivo: (nomeArquivo: string | null | undefined) => tiposArquivo;

/**
 * =============================================================================
 * FILTRO DELTA (zFiltroDelta)
 * =============================================================================
 *
 * OBJETIVO
 * -----------------------------------------------------------------------------
 * Novo sistema de filtros projetado para maior flexibilidade e geração segura
 * de instruções SQL dinâmicas (WHERE).
 *
 * REGRAS IMPORTANTES (PARA IA)
 * -----------------------------------------------------------------------------
 * - O filtro é composto de duas partes obrigatórias: `condicoes` e `formula`.
 * - Apenas referências aos `id`s das `condicoes` podem ser usadas na `formula`.
 * - Não use sintaxe baseada em objetos aninhados para agrupamento (ex: { E: [], OU: [] }). Use fórmulas em string.
 *
 * 1) CONDIÇÕES (`condicoes`):
 * Array de objetos contendo as definições isoladas de cada comparação.
 * Exemplo:
 * [
 *   { id: "{1}", coluna: "idade", operador: ">=", valor: 18 },
 *   { id: "{2}", coluna: "nome", operador: "like", valor: "%pa%" }
 * ]
 * - `id`: Deve SEMPRE seguir o formato {identificador}. Ex: `{c1}`, `{idade_min}`.
 * - `coluna`: O nome da coluna ou um path JSONB válido (ex: `veiculo.ano`).
 * - `operador`: Um dos valores do tipo `tipoOperadorFiltroDelta` (veja a constante).
 *
 * 2) FÓRMULA (`formula`):
 * String que define a expressão lógica relacionando as condições através de seus `id`s.
 * Operadores Lógicos Suportados (EM MAIÚSCULO):
 * - `E` (AND)
 * - `OU` (OR)
 * - `NAO` (NOT)
 * Suporta o agrupamento lógico usando parênteses `()`
 * Exemplo válido: "({1} E NAO({2})) OU {3}"
 *
 * =============================================================================
 */
/**
 * Operadores permitidos para comparação.
 */
declare const zOperadorFiltroDelta: z.ZodEnum<{
    "=": "=";
    "!=": "!=";
    ">": ">";
    ">=": ">=";
    "<": "<";
    "<=": "<=";
    like: "like";
    in: "in";
    "\u2229": "∩";
}>;
declare const operadorFiltroDeltaDetalhes: Record<z.infer<typeof zOperadorFiltroDelta>, {
    rotulo: string;
    descricao: string;
}>;
/**
 * Coluna simples ou caminho aninhado de jsonb.
 */
declare const zColunaFiltroDelta: z.ZodString;
/**
 * Estrutura individual de uma condição do filtro.
 */
declare const zCondicaoFiltroDelta: z.ZodObject<{
    id: z.ZodString;
    coluna: z.ZodString;
    operador: z.ZodEnum<{
        "=": "=";
        "!=": "!=";
        ">": ">";
        ">=": ">=";
        "<": "<";
        "<=": "<=";
        like: "like";
        in: "in";
        "\u2229": "∩";
    }>;
    valor: z.ZodAny;
}, z.core.$strip>;
/**
 * Estrutura principal do filtro delta.
 */
declare const zFiltroDelta: z.ZodObject<{
    condicoes: z.ZodArray<z.ZodObject<{
        id: z.ZodString;
        coluna: z.ZodString;
        operador: z.ZodEnum<{
            "=": "=";
            "!=": "!=";
            ">": ">";
            ">=": ">=";
            "<": "<";
            "<=": "<=";
            like: "like";
            in: "in";
            "\u2229": "∩";
        }>;
        valor: z.ZodAny;
    }, z.core.$strip>>;
    formula: z.ZodString;
}, z.core.$strip>;
type tipoOperadorFiltroDelta = z.infer<typeof zOperadorFiltroDelta>;
type tipoColunaFiltroDelta = z.infer<typeof zColunaFiltroDelta>;
type tipoCondicaoFiltroDelta = z.infer<typeof zCondicaoFiltroDelta>;
type tipoFiltroDelta = z.infer<typeof zFiltroDelta>;
type tipoCondicaoFiltroDeltaTipado<T extends string> = tipoCondicaoFiltroDelta & {
    coluna: T;
};
type tipoFiltroDeltaColunaTipada<T extends string> = {
    condicoes: tipoCondicaoFiltroDeltaTipado<T>[];
    formula: string;
};
declare const criarFiltroDelta: <T extends string>(filtro: tipoFiltroDeltaColunaTipada<T>) => tipoFiltroDeltaColunaTipada<T>;
/**
 * Fábrica para criar filtros com colunas estritamente tipadas.
 * Útil para autocompletar os nomes das colunas e garantir a estrutura no TypeScript.
 *
 * @example
 * ```ts
 * const { criarFiltroDelta } = iniciarFiltroDelta<"nome" | "idade" | "jsonb.propriedade">()
 *
 * const filtro = criarFiltroDelta({
 *   condicoes: [
 *     { id: "{c1}", coluna: "idade", operador: ">", valor: 18 },
 *     { id: "{c2}", coluna: "nome", operador: "=", valor: "luiz" },
 *     { id: "{c3}", coluna: "jsonb.propriedade", operador: "=", valor: "valor" },
 *   ],
 *   formula: "({c1} E {c2}) OU {c3}",
 * })
 * ```
 */
declare const iniciarFiltroDelta: <TColunas extends string>() => {
    criarFiltroDelta: (filtro: tipoFiltroDeltaColunaTipada<TColunas>) => tipoFiltroDeltaColunaTipada<TColunas>;
};

/**
 * LocalStorage Tipado
 * Lê ou grava um valor no localStorage, mantendo o tipo genérico <T>.
 */
declare const localValor: <T>(chave_: string | any, valor?: T | null) => T | null;

/**
 * Trata um objeto para ser imput para postgres
 * @param entrada
 * @returns
 */
declare const paraObjetoRegistroPg: (entrada: {
    [k: string]: any;
}) => {
    [k: string]: string | boolean | null | undefined | number;
};
declare const pgObjeto: (entrada: {
    [k: string]: any;
}) => {
    [k: string]: string | boolean | null | undefined | number;
};
declare const objetoPg: (entrada: {
    [k: string]: any;
}) => {
    [k: string]: string | boolean | null | undefined | number;
};

declare enum Produtos {
    "e-licencie" = "e-licencie",
    "gov.e-licencie" = "gov.e-licencie"
}

declare enum tiposSituacoesElicencie {
    modelo = "000_modelo",
    vencida = "100_vencida",
    expirado = "200_expirado",
    alerta = "300_alerta",
    protocoladafora = "350_protocoladafora",
    protocolada = "400_protocolada",
    protocoladaApenas = "430_protocolada",
    protocolada_alteracao = "450_protocolada",
    prazo = "500_prazo",
    emitida = "515_emitida",
    valida = "518_valida",
    novo = "520_novo",
    recebido = "521_recebido",
    em_andamento = "530_em_andamento",
    aguardando = "530_aguardando",
    aguardandoresposta = "540_aguardandoresposta",
    suspensaotemporaria = "540_suspensaotemporaria",
    cancelada = "550_cancelada",
    execucao = "560_execucao",
    pendente = "570_pendente",
    executadafora = "600_executadafora",
    executada = "700_executada",
    naoexecutada = "701_naoexecutada",
    concluida = "730_concluida",
    respondido_negado = "740_respondido_negado",
    respondido_aceito = "741_respondido_aceito",
    atendidoparcial = "742_atendidoparcial",
    naoatendido = "743_naoatendido",
    atendido = "744_atendido",
    renovada = "760_renovada",
    finalizada = "800_finalizada",
    emitirnota = "101_emitirnota",
    faturaatrasada = "301_faturaatrasada",
    pagarfatura = "302_pagarfatura",
    aguardandoconfirmacao = "531_aguardandoconfirmacao",
    agendado = "701_agendado",
    faturapaga = "801_faturapaga",
    excluida = "999_excluida",
    requerida = "401_requerida",
    vigente = "516_vigente",
    emrenovacao = "402_emrenovacao",
    arquivada = "801_arquivada",
    aguardando_sincronizacao = "999_aguardando_sincronizacao",
    nao_conforme = "710_nao_conforme",
    conforme = "720_conforme",
    nao_aplicavel = "730_nao_aplicavel",
    parcial = "715_parcial"
}

declare const umaFuncao: () => string;

declare const umaVariavel = "Ol\u00E1 Mundo! (vari\u00E1vel)";

/** gerar o texto de busca removendo caracteres especies e caixa alta */
declare const texto_busca: (...texto: any[]) => string;

/** Gerar  uma  classe que  facilita a gestão de  rotas com  a tipagem das  querys
 *
 * Definições:
 *
 * caminho = "/aplicacao/funcionalidade"
 *
 * endereco = "http://localhost:3000/aplicacao/funcionalidade"
 *
 * parametros = {nome:"José"}
 */
declare class TipagemRotas<T extends {
    [q: string]: any;
}> {
    _partesCaminho: string[];
    _acaoIr?: (endereco: string) => undefined;
    rotulo: string | undefined;
    /** Ao criar novo obijeto de tipagem de rota é necessário passar o caminho parcial
     ** export const mCaminho = new TipagemRotas<{q:string}>("aplicacao","funcionalidade")
     */
    constructor({ caminho, acaoIr, rotulo, }: {
        caminho: (string | null | undefined)[] | string;
        acaoIr?: undefined | ((endereco: string) => undefined);
        /** Rotulo da página
         * Inicio | Controle
         */
        rotulo?: string;
    });
    /** Retorna o caminho completo da rota
     ** console.log(mCaminho.caminho)
     ** "/caminho"
     */
    get caminho(): string;
    /** Define o caminho completo da rota
     ** mCaminho.caminho = "/novoCaminho"
     ** console.log(mCaminho.caminho)
     ** "/novoCaminho"
     ** */
    set caminho(caminhoParcial: string);
    /** Retorna o caminho completo da rota com a query
     ** console.log(mCaminho.resolve({q:"query"}))
     ** "http://localhost:3000/caminho?q=query"
     */
    endereco(query: T, usarComoHash?: boolean): string;
    /** Vai para a url
     ** mCaminho.ir({q:"query"})
     ** window.location.href = "http://localhost:3000/caminho?q=query"
     */
    ir(query: T): void;
    /** Retorna os parametros da url
     ** console.log(mCaminho.parametros())
     ** {q:"query"}
     */
    parametros(urlEntrada?: string): Partial<T>;
}

/**
 * Essa variável se conecta a tabela_lidades
 *
 * onde sigla se conecta com  sigla
 *
 * Usuário terá mais opções de unidades, quando fazer o envio para o mtr, usar a opção fornecida pelo usuarios, caso não tenha
 * usar a normalizada
 */
declare enum siglas_unidades_medida {
    UN = "UN",
    KG = "KG",
    TON = "TON",
    g = "g",
    "M³" = "M\u00B3",
    Lt = "Lt"
}
declare const unidades_medida: {
    sigla_unidade: keyof typeof siglas_unidades_medida;
    nome: string;
    sigla_normalizada: keyof typeof siglas_unidades_medida;
    normalizar: (valor: number) => number;
    tipo: "massa" | "volume" | "comprimento" | "unidade";
}[];

/**
 * Valida se uma string é um UUID válido (qualquer versão).
 *
 * @param valor - A string que será validada.
 * @returns booleano indicando se é um UUID válido.
 */
declare const erUuid: RegExp;
declare const validarUuid: (uuid: string | number | undefined | null) => boolean;
/**
 * Gera um UUID determinístico (versão 3) com base em uma chave e um grupo (namespace).
 *
 * - Usa o algoritmo MD5 (RFC 4122).
 * - Sempre retorna o mesmo UUID para a mesma combinação chave + grupo.
 * - Caso o grupo não seja informado, usa o UUID "nil" como namespace.
 *
 * @param chave - Qualquer valor que será convertido em string para gerar o UUID (ex: número, string ou objeto).
 * @param grupo - Opcional. Namespace para separar domínios diferentes de UUIDs.
 * @returns UUID v3 (determinístico)
 */
declare const uuidV3: (chave: any, grupo?: any) => string;
/**
 * Gera um UUID v4 (aleatório, não determinístico).
 *
 * - Usado quando unicidade é necessária, mas não se exige que seja previsível.
 */
declare const uuidV4: typeof v4;
/**
 * @deprecated Esta variável será descontinuada em versões futuras.
 * Use a função `uuidV4()` diretamente.
 */
declare const uuid: typeof v4;

declare const esperar: (ms: number) => Promise<true>;
/**
 * Usado para retronat o no de uma variável, deve ser usado dentro de um objeto
 * const nomex = {a: 1, b: 2}
 * nomeVariavel({nomex}) // retorna "nomex"
 * @param v
 * @returns
 */
declare const nomeVariavel: (v: {
    [key: string]: any;
}) => string;

/**
 * No futuro podemos melhorar este Zod para incluir mais formatos de coordenadas.
 *
 */

declare const zCoordenadas: z.ZodObject<{
    formato: z.ZodDefault<z.ZodLiteral<"decimal">>;
    datum: z.ZodDefault<z.ZodLiteral<"EPSG:4326">>;
    latitude: z.ZodNumber;
    longitude: z.ZodNumber;
}, z.core.$strip>;

declare const zDocCnpj: z.ZodString;
declare const zDocCpf: z.ZodString;
declare const zDocumento: z.ZodUnion<[z.ZodString, z.ZodString]>;

/**
 * Schema numérico que aceita strings legadas e normaliza para `number`.
 *
 * O campo **é** um número. O `preprocess` resolve compatibilidade com dados
 * antigos onde o frontend enviava strings formatadas (BR ou monetária).
 *
 * Formatos de entrada aceitos:
 * - `10`        → number direto
 * - `10.1`      → ponto decimal
 * - `10,1`      → vírgula decimal (BR)
 * - `1.000,1`   → milhar com ponto + vírgula decimal (BR)
 * - `R$ 10,01`  → prefixo monetário legado
 */
declare const zNumero: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
declare const zNumeroPositivo: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;
declare const zNumeroInteiro: z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>;

export { Produtos, TipagemRotas, type TipoPayloadAuditoria, aleatorio, cacheM, cacheMFixo, cacheMemoria, camposComuns, criarFiltroDelta, defineDayjsBr, erUuid, esperar, extensoes, iniciarDayjsBr, iniciarFiltroDelta, type interfaceConsulta, link_paiol, localValor, nomeVariavel, objetoPg, operadorFiltroDeltaDetalhes, operadores, paraObjetoRegistroPg, pgObjeto, siglas_unidades_medida, texto_busca, tipoArquivo, type tipoColunaFiltroDelta, type tipoCondicaoFiltroDelta, type tipoCondicaoFiltroDeltaTipado, type tipoFiltro, type tipoFiltroDelta, type tipoFiltroDeltaColunaTipada, type tipoOperadorFiltroDelta, tipoUsuarioResiduos, tiposSituacoesElicencie, tx, umaFuncao, umaVariavel, unidades_medida, uuid, uuidV3, uuidV4, uuid_null, validarUuid, verCacheM, zColunaFiltroDelta, zCondicaoFiltroDelta, zCoordenadas, zDocCnpj, zDocCpf, zDocumento, zFiltro, zFiltroDelta, zNumero, zNumeroInteiro, zNumeroPositivo, zOperadorFiltroDelta, zOperadores };