import z, { z as z$1 } 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;

/** 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 { defineDayjsBr } from "p-comuns"
 *       import "dayjs/locale/pt-br" // Importante: importar o locale!

 *       export const dayjsbr = defineDayjsBr({
 *       dayjs,
 *       duration,
 *       isSameOrAfter,
 *       isSameOrBefore,
 *       minMax,
 *       relativeTime,
 *       timezone,
 *       utc,
 *       weekOfYear,
 *       })
 * ```
 */
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;

/**
 * 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>;
}

/**
 * =============================================================================
 * tipoFiltro26<T>
 * =============================================================================
 *
 * OBJETIVO
 * -----------------------------------------------------------------------------
 * Gerar automaticamente a tipagem de filtros compatíveis com operadores
 * padrão do PostgreSQL, a partir de um tipo base T.
 *
 * Este tipo foi projetado para:
 * - Construção de filtros dinâmicos
 * - Geração posterior de WHERE (Knex / SQL)
 * - Uso seguro por IA (evita filtros inválidos em nível de tipo)
 *
 *
 * FORMATO DO FILTRO
 * -----------------------------------------------------------------------------
 * 1) Campos simples:
 *
 * {
 *   idade: { ">=": 18 }
 * }
 *
 * 2) Campos aninhados:
 *
 * {
 *   carro: {
 *     ano: { "=": 2020 }
 *   }
 * }
 *
 * 3) Operador E (AND):
 *
 * {
 *   E: [
 *     { idade: { ">=": 18 } },
 *     { nome: { like: "%pa%" } }
 *   ]
 * }
 *
 * 4) Operador OU (OR):
 *
 * {
 *   OU: [
 *     { idade: { "<": 18 } },
 *     { idade: { ">=": 60 } }
 *   ]
 * }
 *
 * 5) Combinação complexa:
 *
 * {
 *   idade: { ">=": 18 },
 *   OU: [
 *     { nome: { like: "%pa%" } },
 *     {
 *       E: [
 *         { carro: { ano: { "=": 2020 } } },
 *         { carro: { modelo: { in: ["Civic"] } } }
 *       ]
 *     }
 *   ]
 * }
 *
 *
 * REGRAS IMPORTANTES (PARA IA)
 * -----------------------------------------------------------------------------
 * - Apenas campos existentes em T podem ser usados.
 * - Operadores são restritos por tipo do campo.
 * - Objetos são tratados recursivamente.
 * - Arrays NÃO são tratados como objeto recursivo.
 * - Funções NÃO são consideradas campos filtráveis.
 *
 *
 * OPERADORES SUPORTADOS
 * -----------------------------------------------------------------------------
 * number:
 *   =, !=, >, >=, <, <=, in
 *
 * string:
 *   =, !=, like, in
 *
 * boolean:
 *   =, !=, in
 *
 * Não há suporte automático a:
 *   - null
 *   - date
 *   - jsonb
 *   - arrays
 *
 * Essas extensões devem ser adicionadas explicitamente.
 *
 * =============================================================================
 */
declare enum operadores26 {
    "=" = "=",
    "!=" = "!=",
    ">" = ">",
    ">=" = ">=",
    "<" = "<",
    "<=" = "<=",
    like = "like",
    in = "in"
}
declare enum agrupadores26 {
    E = "E",
    OU = "OU"
}
type PgOpsNumber = {
    [K in Extract<operadores26, "=" | "!=" | ">" | ">=" | "<" | "<=">]?: number;
} & {
    [K in Extract<operadores26, "in">]?: number[];
};
type PgOpsString = {
    [K in Extract<operadores26, "=" | "!=" | "like">]?: string;
} & {
    [K in Extract<operadores26, "in">]?: string[];
};
type PgOpsBoolean = {
    [K in Extract<operadores26, "=" | "!=">]?: boolean;
} & {
    [K in Extract<operadores26, "in">]?: boolean[];
};
type PgOpsFor<V> = V extends number ? PgOpsNumber : V extends string ? PgOpsString : V extends boolean ? PgOpsBoolean : never;
type IsPlainObject<T> = T extends object ? T extends Function ? false : T extends readonly any[] ? false : true : false;
type FiltroCampos<T> = {
    [K in keyof T]?: IsPlainObject<T[K]> extends true ? tipoFiltro26<T[K]> : PgOpsFor<T[K]>;
};
type tipoFiltro26<T> = FiltroCampos<T> & {
    /**
     * E  => AND lógico
     * Todos os filtros dentro do array devem ser verdadeiros.
     */
    E?: tipoFiltro26<T>[];
    /**
     * OU => OR lógico
     * Pelo menos um filtro dentro do array deve ser verdadeiro.
     */
    OU?: tipoFiltro26<T>[];
};
declare const zFiltro26: z$1.ZodType<any>;
declare const criarFiltro26: <T>(filtro: tipoFiltro26<T>) => tipoFiltro26<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;

export { Produtos, TipagemRotas, agrupadores26, aleatorio, cacheM, cacheMFixo, cacheMemoria, camposComuns, criarFiltro26, defineDayjsBr, erUuid, esperar, extensoes, type interfaceConsulta, link_paiol, localValor, nomeVariavel, objetoPg, operadores, operadores26, paraObjetoRegistroPg, pgObjeto, siglas_unidades_medida, texto_busca, tipoArquivo, type tipoFiltro, type tipoFiltro26, tipoUsuarioResiduos, tiposSituacoesElicencie, tx, umaFuncao, umaVariavel, unidades_medida, uuid, uuidV3, uuidV4, uuid_null, validarUuid, verCacheM, zFiltro, zFiltro26, zOperadores };